CacheControl

org.springframework.http.CacheControl

protected CacheControl CacheControl()

{
}
org.springframework.http.CacheControl

public CacheControl cachePrivate()

{
    this.cachePrivate = true;
    return this;
}
org.springframework.http.CacheControl

public CacheControl cachePublic()

{
    this.cachePublic = true;
    return this;
}
org.springframework.http.CacheControl

public static CacheControl empty()

{
    return new CacheControl();
}
org.springframework.http.CacheControl

@Nullable public String getHeaderValue()

{
    String headerValue = toHeaderValue();
    return (StringUtils.hasText(headerValue) ? headerValue : null);
}
org.springframework.http.CacheControl

public static CacheControl maxAge(long maxAge, TimeUnit unit)

{
    return maxAge(Duration.ofSeconds(unit.toSeconds(maxAge)));
}
org.springframework.http.CacheControl

public static CacheControl maxAge(Duration maxAge)

{
    CacheControl cc = new CacheControl();
    cc.maxAge = maxAge;
    return cc;
}
org.springframework.http.CacheControl

public CacheControl mustRevalidate()

{
    this.mustRevalidate = true;
    return this;
}
org.springframework.http.CacheControl

public static CacheControl noCache()

{
    CacheControl cc = new CacheControl();
    cc.noCache = true;
    return cc;
}
org.springframework.http.CacheControl

public static CacheControl noStore()

{
    CacheControl cc = new CacheControl();
    cc.noStore = true;
    return cc;
}
org.springframework.http.CacheControl

public CacheControl noTransform()

{
    this.noTransform = true;
    return this;
}
org.springframework.http.CacheControl

public CacheControl proxyRevalidate()

{
    this.proxyRevalidate = true;
    return this;
}
org.springframework.http.CacheControl

public CacheControl sMaxAge(long sMaxAge, TimeUnit unit)

{
    return sMaxAge(Duration.ofSeconds(unit.toSeconds(sMaxAge)));
}
org.springframework.http.CacheControl

public CacheControl sMaxAge(Duration sMaxAge)

{
    this.sMaxAge = sMaxAge;
    return this;
}
org.springframework.http.CacheControl

public CacheControl staleIfError(long staleIfError, TimeUnit unit)

{
    return staleIfError(Duration.ofSeconds(unit.toSeconds(staleIfError)));
}
org.springframework.http.CacheControl

public CacheControl staleIfError(Duration staleIfError)

{
    this.staleIfError = staleIfError;
    return this;
}
org.springframework.http.CacheControl

public CacheControl staleWhileRevalidate(long staleWhileRevalidate, TimeUnit unit)

{
    return staleWhileRevalidate(Duration.ofSeconds(unit.toSeconds(staleWhileRevalidate)));
}
org.springframework.http.CacheControl

public CacheControl staleWhileRevalidate(Duration staleWhileRevalidate)

{
    this.staleWhileRevalidate = staleWhileRevalidate;
    return this;
}
org.springframework.http.CacheControl

@Override public String toString()

{
    return "CacheControl [" + toHeaderValue() + "]";
}

ContentDisposition

Builder
org.springframework.http.ContentDisposition

public static Builder builder(String type)

{
    return new BuilderImpl(type);
}
org.springframework.http.ContentDisposition

public static ContentDisposition empty()

{
    return new ContentDisposition("", null, null, null, null, null, null, null);
}
org.springframework.http.ContentDisposition

@Override public boolean equals(@Nullable Object other)

{
    if (this == other) {
        return true;
    } 
    if (!(other instanceof ContentDisposition)) {
        return false;
    } 
    ContentDisposition otherCd = (ContentDisposition)other;
    return (ObjectUtils.nullSafeEquals(this.type, otherCd.type) && ObjectUtils.nullSafeEquals(this.name, otherCd.name) && ObjectUtils.nullSafeEquals(this.filename, otherCd.filename) && ObjectUtils.nullSafeEquals(this.charset, otherCd.charset) && ObjectUtils.nullSafeEquals(this.size, otherCd.size) && ObjectUtils.nullSafeEquals(this.creationDate, otherCd.creationDate) && ObjectUtils.nullSafeEquals(this.modificationDate, otherCd.modificationDate) && ObjectUtils.nullSafeEquals(this.readDate, otherCd.readDate));
}
org.springframework.http.ContentDisposition

@Nullable public Charset getCharset()

{
    return this.charset;
}
org.springframework.http.ContentDisposition

@Nullable public ZonedDateTime getCreationDate()

{
    return this.creationDate;
}
org.springframework.http.ContentDisposition

@Nullable public String getFilename()

{
    return this.filename;
}
org.springframework.http.ContentDisposition

@Nullable public ZonedDateTime getModificationDate()

{
    return this.modificationDate;
}
org.springframework.http.ContentDisposition

@Nullable public String getName()

{
    return this.name;
}
org.springframework.http.ContentDisposition

@Nullable public ZonedDateTime getReadDate()

{
    return this.readDate;
}
org.springframework.http.ContentDisposition

@Nullable public Long getSize()

{
    return this.size;
}
org.springframework.http.ContentDisposition

@Nullable public String getType()

{
    return this.type;
}
org.springframework.http.ContentDisposition

public static ContentDisposition parse(String contentDisposition)

{
    List<String> parts = tokenize(contentDisposition);
    String type = parts.get(0);
    String name = null;
    String filename = null;
    Charset charset = null;
    Long size = null;
    ZonedDateTime creationDate = null;
    ZonedDateTime modificationDate = null;
    ZonedDateTime readDate = null;
    for (int i = 1; i < parts.size(); i++) {
        String part = parts.get(i);
        int eqIndex = part.indexOf('=');
        if (eqIndex != -1) {
            String attribute = part.substring(0, eqIndex);
            String value = (part.startsWith("\"", eqIndex + 1) && part.endsWith("\"") ? part.substring(eqIndex + 2, part.length() - 1) : part.substring(eqIndex + 1));
            if (attribute.equals("name")) {
                name = value;
            } else if (attribute.equals("filename*")) {
                int idx1 = value.indexOf('\'');
                int idx2 = value.indexOf('\'', idx1 + 1);
                if (idx1 != -1 && idx2 != -1) {
                    charset = Charset.forName(value.substring(0, idx1));
                    Assert.isTrue(UTF_8.equals(charset) || ISO_8859_1.equals(charset), "Charset should be UTF-8 or ISO-8859-1");
                    filename = decodeFilename(value.substring(idx2 + 1), charset);
                } else {
                    filename = decodeFilename(value, StandardCharsets.US_ASCII);
                }
            } else if (attribute.equals("filename") && (filename == null)) {
                filename = value;
            } else if (attribute.equals("size")) {
                size = Long.parseLong(value);
            } else if (attribute.equals("creation-date")) {
                try {
                    creationDate = ZonedDateTime.parse(value, RFC_1123_DATE_TIME);
                } catch (DateTimeParseException ex) {
                }
            } else if (attribute.equals("modification-date")) {
                try {
                    modificationDate = ZonedDateTime.parse(value, RFC_1123_DATE_TIME);
                } catch (DateTimeParseException ex) {
                }
            } else if (attribute.equals("read-date")) {
                try {
                    readDate = ZonedDateTime.parse(value, RFC_1123_DATE_TIME);
                } catch (DateTimeParseException ex) {
                }
            } 
        } else {
            throw new IllegalArgumentException("Invalid content disposition format");
        }
    }
    return new ContentDisposition(type, name, filename, charset, size, creationDate, modificationDate, readDate);
}

HttpCookie

org.springframework.http.HttpCookie

public HttpCookie HttpCookie(String name, @Nullable String value)

{
    Assert.hasLength(name, "'name' is required and must not be empty.");
    this.name = name;
    this.value = (value != null ? value : "");
}
org.springframework.http.HttpCookie

@Override public boolean equals(@Nullable Object other)

{
    if (this == other) {
        return true;
    } 
    if (!(other instanceof HttpCookie)) {
        return false;
    } 
    HttpCookie otherCookie = (HttpCookie)other;
    return (this.name.equalsIgnoreCase(otherCookie.getName()));
}
org.springframework.http.HttpCookie

public String getName()

{
    return this.name;
}
org.springframework.http.HttpCookie

public String getValue()

{
    return this.value;
}
org.springframework.http.HttpCookie

@Override public int hashCode()

{
    return this.name.hashCode();
}
org.springframework.http.HttpCookie

@Override public String toString()

{
    return this.name + '=' + this.value;
}

HttpEntity<T>

org.springframework.http.HttpEntity

public static final HttpEntity<?> EMPTY

org.springframework.http.HttpEntity

protected HttpEntity HttpEntity()

{
    this(null, null);
}
org.springframework.http.HttpEntity

public HttpEntity HttpEntity(T body)

{
    this(body, null);
}
org.springframework.http.HttpEntity

public HttpEntity HttpEntity(MultiValueMap<String, String> headers)

{
    this(null, headers);
}
org.springframework.http.HttpEntity

public HttpEntity HttpEntity(@Nullable T body, @Nullable MultiValueMap<String, String> headers)

{
    this.body = body;
    HttpHeaders tempHeaders = new HttpHeaders();
    if (headers != null) {
        tempHeaders.putAll(headers);
    } 
    this.headers = HttpHeaders.readOnlyHttpHeaders(tempHeaders);
}
org.springframework.http.HttpEntity

@Override public boolean equals(@Nullable Object other)

{
    if (this == other) {
        return true;
    } 
    if (other == null || other.getClass() != getClass()) {
        return false;
    } 
    HttpEntity<?> otherEntity = (HttpEntity<?>)other;
    return (ObjectUtils.nullSafeEquals(this.headers, otherEntity.headers) && ObjectUtils.nullSafeEquals(this.body, otherEntity.body));
}
org.springframework.http.HttpEntity

@Nullable public T getBody()

{
    return this.body;
}
org.springframework.http.HttpEntity

public HttpHeaders getHeaders()

{
    return this.headers;
}
org.springframework.http.HttpEntity

public boolean hasBody()

{
    return (this.body != null);
}
org.springframework.http.HttpEntity

@Override public String toString()

{
    StringBuilder builder = new StringBuilder("<");
    if (this.body != null) {
        builder.append(this.body);
        builder.append(',');
    } 
    builder.append(this.headers);
    builder.append('>');
    return builder.toString();
}

HttpHeaders
implements MultiValueMap<String, String>, Serializable

org.springframework.http.HttpHeaders

public static final String ACCEPT

org.springframework.http.HttpHeaders

public static final String ACCEPT_CHARSET

org.springframework.http.HttpHeaders

public static final String ACCEPT_ENCODING

org.springframework.http.HttpHeaders

public static final String ACCEPT_LANGUAGE

org.springframework.http.HttpHeaders

public static final String ACCEPT_RANGES

org.springframework.http.HttpHeaders

public static final String ACCESS_CONTROL_ALLOW_CREDENTIALS

org.springframework.http.HttpHeaders

public static final String ACCESS_CONTROL_ALLOW_HEADERS

org.springframework.http.HttpHeaders

public static final String ACCESS_CONTROL_ALLOW_METHODS

org.springframework.http.HttpHeaders

public static final String ACCESS_CONTROL_ALLOW_ORIGIN

org.springframework.http.HttpHeaders

public static final String ACCESS_CONTROL_EXPOSE_HEADERS

org.springframework.http.HttpHeaders

public static final String ACCESS_CONTROL_MAX_AGE

org.springframework.http.HttpHeaders

public static final String ACCESS_CONTROL_REQUEST_HEADERS

org.springframework.http.HttpHeaders

public static final String ACCESS_CONTROL_REQUEST_METHOD

org.springframework.http.HttpHeaders

public static final String AGE

org.springframework.http.HttpHeaders

public static final String ALLOW

org.springframework.http.HttpHeaders

public static final String AUTHORIZATION

org.springframework.http.HttpHeaders

public static final String CACHE_CONTROL

org.springframework.http.HttpHeaders

public static final String CONNECTION

org.springframework.http.HttpHeaders

public static final String CONTENT_DISPOSITION

org.springframework.http.HttpHeaders

public static final String CONTENT_ENCODING

org.springframework.http.HttpHeaders

public static final String CONTENT_LANGUAGE

org.springframework.http.HttpHeaders

public static final String CONTENT_LENGTH

org.springframework.http.HttpHeaders

public static final String CONTENT_LOCATION

org.springframework.http.HttpHeaders

public static final String CONTENT_RANGE

org.springframework.http.HttpHeaders

public static final String CONTENT_TYPE

org.springframework.http.HttpHeaders

public static final String DATE

org.springframework.http.HttpHeaders

public static final HttpHeaders EMPTY

org.springframework.http.HttpHeaders

public static final String ETAG

org.springframework.http.HttpHeaders

public static final String EXPECT

org.springframework.http.HttpHeaders

public static final String EXPIRES

org.springframework.http.HttpHeaders

public static final String FROM

org.springframework.http.HttpHeaders

public static final String HOST

org.springframework.http.HttpHeaders

public HttpHeaders HttpHeaders()

{
    this(CollectionUtils.toMultiValueMap(new LinkedCaseInsensitiveMap<>(8, Locale.ENGLISH)));
}
org.springframework.http.HttpHeaders

public HttpHeaders HttpHeaders(MultiValueMap<String, String> headers)

{
    Assert.notNull(headers, "MultiValueMap must not be null");
    this.headers = headers;
}
org.springframework.http.HttpHeaders

public static final String IF_MATCH

org.springframework.http.HttpHeaders

public static final String IF_MODIFIED_SINCE

org.springframework.http.HttpHeaders

public static final String IF_NONE_MATCH

org.springframework.http.HttpHeaders

public static final String IF_RANGE

org.springframework.http.HttpHeaders

public static final String IF_UNMODIFIED_SINCE

org.springframework.http.HttpHeaders

public static final String LAST_MODIFIED

org.springframework.http.HttpHeaders

public static final String LOCATION

org.springframework.http.HttpHeaders

public static final String MAX_FORWARDS

org.springframework.http.HttpHeaders

public static final String ORIGIN

org.springframework.http.HttpHeaders

public static final String PRAGMA

org.springframework.http.HttpHeaders

public static final String PROXY_AUTHENTICATE

org.springframework.http.HttpHeaders

public static final String PROXY_AUTHORIZATION

org.springframework.http.HttpHeaders

public static final String RANGE

org.springframework.http.HttpHeaders

public static final String REFERER

org.springframework.http.HttpHeaders

public static final String RETRY_AFTER

org.springframework.http.HttpHeaders

public static final String SERVER

org.springframework.http.HttpHeaders

public static final String SET_COOKIE2

org.springframework.http.HttpHeaders

public static final String TE

org.springframework.http.HttpHeaders

public static final String TRAILER

org.springframework.http.HttpHeaders

public static final String TRANSFER_ENCODING

org.springframework.http.HttpHeaders

public static final String UPGRADE

org.springframework.http.HttpHeaders

public static final String USER_AGENT

org.springframework.http.HttpHeaders

public static final String VARY

org.springframework.http.HttpHeaders

public static final String VIA

org.springframework.http.HttpHeaders

public static final String WARNING

org.springframework.http.HttpHeaders

public static final String WWW_AUTHENTICATE

org.springframework.http.HttpHeaders

@Override public void add(String headerName, @Nullable String headerValue)

{
    this.headers.add(headerName, headerValue);
}
org.springframework.http.HttpHeaders

@Override public void addAll(String key, List<?> values)

{
    this.headers.addAll(key, values);
}
org.springframework.http.HttpHeaders

@Override public void addAll(MultiValueMap<String, String> values)

{
    this.headers.addAll(values);
}
org.springframework.http.HttpHeaders

@Override public void clear()

{
    this.headers.clear();
}
org.springframework.http.HttpHeaders

@Override public boolean containsKey(Object key)

{
    return this.headers.containsKey(key);
}
org.springframework.http.HttpHeaders

@Override public boolean containsValue(Object value)

{
    return this.headers.containsValue(value);
}
org.springframework.http.HttpHeaders

public static String encodeBasicAuth(String username, String password, @Nullable Charset charset)

{
    Assert.notNull(username, "Username must not be null");
    Assert.doesNotContain(username, ":", "Username must not contain a colon");
    Assert.notNull(password, "Password must not be null");
    if (charset == null) {
        charset = StandardCharsets.ISO_8859_1;
    } 
    CharsetEncoder encoder = charset.newEncoder();
    if (!encoder.canEncode(username) || !encoder.canEncode(password)) {
        throw new IllegalArgumentException("Username or password contains characters that cannot be encoded to " + charset.displayName());
    } 
    String credentialsString = username + ":" + password;
    byte[] encodedBytes = Base64.getEncoder().encode(credentialsString.getBytes(charset));
    return new String(encodedBytes, charset);
}
org.springframework.http.HttpHeaders

@Override public Set<Entry<String, List<String>>> entrySet()

{
    return this.headers.entrySet();
}
org.springframework.http.HttpHeaders

@Override public boolean equals(@Nullable Object other)

{
    if (this == other) {
        return true;
    } 
    if (!(other instanceof HttpHeaders)) {
        return false;
    } 
    HttpHeaders otherHeaders = (HttpHeaders)other;
    return this.headers.equals(otherHeaders.headers);
}
org.springframework.http.HttpHeaders

@Override @Nullable public List<String> get(Object key)

{
    return this.headers.get(key);
}
org.springframework.http.HttpHeaders

public List<MediaType> getAccept()

{
    return MediaType.parseMediaTypes(get(ACCEPT));
}
org.springframework.http.HttpHeaders

public List<Locale> getAcceptLanguageAsLocales()

{
    List<Locale.LanguageRange> ranges = getAcceptLanguage();
    if (ranges.isEmpty()) {
        return Collections.emptyList();
    } 
    return ranges.stream().map(range -> Locale.forLanguageTag(range.getRange())).filter(locale -> StringUtils.hasText(locale.getDisplayName())).collect(Collectors.toList());
}
org.springframework.http.HttpHeaders

public boolean getAccessControlAllowCredentials()

{
    return Boolean.parseBoolean(getFirst(ACCESS_CONTROL_ALLOW_CREDENTIALS));
}
org.springframework.http.HttpHeaders

public List<String> getAccessControlAllowHeaders()

{
    return getValuesAsList(ACCESS_CONTROL_ALLOW_HEADERS);
}
org.springframework.http.HttpHeaders

@Nullable public String getAccessControlAllowOrigin()

{
    return getFieldValues(ACCESS_CONTROL_ALLOW_ORIGIN);
}
org.springframework.http.HttpHeaders

public List<String> getAccessControlExposeHeaders()

{
    return getValuesAsList(ACCESS_CONTROL_EXPOSE_HEADERS);
}
org.springframework.http.HttpHeaders

public long getAccessControlMaxAge()

{
    String value = getFirst(ACCESS_CONTROL_MAX_AGE);
    return (value != null ? Long.parseLong(value) : -1);
}
org.springframework.http.HttpHeaders

public List<String> getAccessControlRequestHeaders()

{
    return getValuesAsList(ACCESS_CONTROL_REQUEST_HEADERS);
}
org.springframework.http.HttpHeaders

@Nullable public HttpMethod getAccessControlRequestMethod()

{
    return HttpMethod.resolve(getFirst(ACCESS_CONTROL_REQUEST_METHOD));
}
org.springframework.http.HttpHeaders

@Nullable public String getCacheControl()

{
    return getFieldValues(CACHE_CONTROL);
}
org.springframework.http.HttpHeaders

public List<String> getConnection()

{
    return getValuesAsList(CONNECTION);
}
org.springframework.http.HttpHeaders

public ContentDisposition getContentDisposition()

{
    String contentDisposition = getFirst(CONTENT_DISPOSITION);
    if (contentDisposition != null) {
        return ContentDisposition.parse(contentDisposition);
    } 
    return ContentDisposition.empty();
}
org.springframework.http.HttpHeaders

@Nullable public Locale getContentLanguage()

{
    return getValuesAsList(CONTENT_LANGUAGE).stream().findFirst().map(Locale::forLanguageTag).orElse(null);
}
org.springframework.http.HttpHeaders

public long getContentLength()

{
    String value = getFirst(CONTENT_LENGTH);
    return (value != null ? Long.parseLong(value) : -1);
}
org.springframework.http.HttpHeaders

public long getDate()

{
    return getFirstDate(DATE);
}
org.springframework.http.HttpHeaders

@Nullable public String getETag()

{
    return getFirst(ETAG);
}
org.springframework.http.HttpHeaders

public long getExpires()

{
    return getFirstDate(EXPIRES, false);
}
org.springframework.http.HttpHeaders

@Nullable protected String getFieldValues(String headerName)

{
    List<String> headerValues = get(headerName);
    return (headerValues != null ? toCommaDelimitedString(headerValues) : null);
}
org.springframework.http.HttpHeaders

@Override @Nullable public String getFirst(String headerName)

{
    return this.headers.getFirst(headerName);
}
org.springframework.http.HttpHeaders

public long getFirstDate(String headerName)

{
    return getFirstDate(headerName, true);
}
org.springframework.http.HttpHeaders

@Nullable public ZonedDateTime getFirstZonedDateTime(String headerName)

{
    return getFirstZonedDateTime(headerName, true);
}
org.springframework.http.HttpHeaders

@Nullable public InetSocketAddress getHost()

{
    String value = getFirst(HOST);
    if (value == null) {
        return null;
    } 
    String host = null;
    int port = 0;
    int separator = (value.startsWith("[") ? value.indexOf(':', value.indexOf(']')) : value.lastIndexOf(':'));
    if (separator != -1) {
        host = value.substring(0, separator);
        String portString = value.substring(separator + 1);
        try {
            port = Integer.parseInt(portString);
        } catch (NumberFormatException ex) {
        }
    } 
    if (host == null) {
        host = value;
    } 
    return InetSocketAddress.createUnresolved(host, port);
}
org.springframework.http.HttpHeaders

public List<String> getIfMatch()

{
    return getETagValuesAsList(IF_MATCH);
}
org.springframework.http.HttpHeaders

public long getIfModifiedSince()

{
    return getFirstDate(IF_MODIFIED_SINCE, false);
}
org.springframework.http.HttpHeaders

public List<String> getIfNoneMatch()

{
    return getETagValuesAsList(IF_NONE_MATCH);
}
org.springframework.http.HttpHeaders

public long getIfUnmodifiedSince()

{
    return getFirstDate(IF_UNMODIFIED_SINCE, false);
}
org.springframework.http.HttpHeaders

public long getLastModified()

{
    return getFirstDate(LAST_MODIFIED, false);
}
org.springframework.http.HttpHeaders

@Nullable public URI getLocation()

{
    String value = getFirst(LOCATION);
    return (value != null ? URI.create(value) : null);
}
org.springframework.http.HttpHeaders

public List<String> getOrEmpty(Object headerName)

{
    List<String> values = get(headerName);
    return (values != null ? values : Collections.emptyList());
}
org.springframework.http.HttpHeaders

@Nullable public String getOrigin()

{
    return getFirst(ORIGIN);
}
org.springframework.http.HttpHeaders

@Nullable public String getPragma()

{
    return getFirst(PRAGMA);
}
org.springframework.http.HttpHeaders

public List<HttpRange> getRange()

{
    String value = getFirst(RANGE);
    return HttpRange.parseRanges(value);
}
org.springframework.http.HttpHeaders

@Nullable public String getUpgrade()

{
    return getFirst(UPGRADE);
}
org.springframework.http.HttpHeaders

public List<String> getVary()

{
    return getValuesAsList(VARY);
}
org.springframework.http.HttpHeaders

@Override public int hashCode()

{
    return this.headers.hashCode();
}
org.springframework.http.HttpHeaders

@Override public boolean isEmpty()

{
    return this.headers.isEmpty();
}
org.springframework.http.HttpHeaders

@Override public Set<String> keySet()

{
    return this.headers.keySet();
}
org.springframework.http.HttpHeaders

@Override public List<String> put(String key, List<String> value)

{
    return this.headers.put(key, value);
}
org.springframework.http.HttpHeaders

@Override public void putAll(Map<?, ?> map)

{
    this.headers.putAll(map);
}
org.springframework.http.HttpHeaders

@Override public List<String> remove(Object key)

{
    return this.headers.remove(key);
}
org.springframework.http.HttpHeaders

@Override public void set(String headerName, @Nullable String headerValue)

{
    this.headers.set(headerName, headerValue);
}
org.springframework.http.HttpHeaders

public void setAccept(List<MediaType> acceptableMediaTypes)

{
    set(ACCEPT, MediaType.toString(acceptableMediaTypes));
}
org.springframework.http.HttpHeaders

public void setAcceptCharset(List<Charset> acceptableCharsets)

{
    StringJoiner joiner = new StringJoiner(", ");
    for (Charset charset: acceptableCharsets) {
        joiner.add(charset.name().toLowerCase(Locale.ENGLISH));
    }
    set(ACCEPT_CHARSET, joiner.toString());
}
org.springframework.http.HttpHeaders

public void setAcceptLanguageAsLocales(List<Locale> locales)

{
    setAcceptLanguage(locales.stream().map(locale -> new Locale.LanguageRange(locale.toLanguageTag())).collect(Collectors.toList()));
}
org.springframework.http.HttpHeaders

public void setAccessControlAllowCredentials(boolean allowCredentials)

{
    set(ACCESS_CONTROL_ALLOW_CREDENTIALS, Boolean.toString(allowCredentials));
}
org.springframework.http.HttpHeaders

public void setAccessControlAllowHeaders(List<String> allowedHeaders)

{
    set(ACCESS_CONTROL_ALLOW_HEADERS, toCommaDelimitedString(allowedHeaders));
}
org.springframework.http.HttpHeaders

public void setAccessControlAllowMethods(List<HttpMethod> allowedMethods)

{
    set(ACCESS_CONTROL_ALLOW_METHODS, StringUtils.collectionToCommaDelimitedString(allowedMethods));
}
org.springframework.http.HttpHeaders

public void setAccessControlAllowOrigin(@Nullable String allowedOrigin)

{
    setOrRemove(ACCESS_CONTROL_ALLOW_ORIGIN, allowedOrigin);
}
org.springframework.http.HttpHeaders

public void setAccessControlExposeHeaders(List<String> exposedHeaders)

{
    set(ACCESS_CONTROL_EXPOSE_HEADERS, toCommaDelimitedString(exposedHeaders));
}
org.springframework.http.HttpHeaders

public void setAccessControlMaxAge(Duration maxAge)

{
    set(ACCESS_CONTROL_MAX_AGE, Long.toString(maxAge.getSeconds()));
}
org.springframework.http.HttpHeaders

public void setAccessControlMaxAge(long maxAge)

{
    set(ACCESS_CONTROL_MAX_AGE, Long.toString(maxAge));
}
org.springframework.http.HttpHeaders

public void setAccessControlRequestHeaders(List<String> requestHeaders)

{
    set(ACCESS_CONTROL_REQUEST_HEADERS, toCommaDelimitedString(requestHeaders));
}
org.springframework.http.HttpHeaders

public void setAccessControlRequestMethod(@Nullable HttpMethod requestMethod)

{
    setOrRemove(ACCESS_CONTROL_REQUEST_METHOD, (requestMethod != null ? requestMethod.name() : null));
}
org.springframework.http.HttpHeaders

@Override public void setAll(Map<String, String> values)

{
    this.headers.setAll(values);
}
org.springframework.http.HttpHeaders

public void setAllow(Set<HttpMethod> allowedMethods)

{
    set(ALLOW, StringUtils.collectionToCommaDelimitedString(allowedMethods));
}
org.springframework.http.HttpHeaders

public void setBasicAuth(String username, String password)

{
    setBasicAuth(username, password, null);
}
org.springframework.http.HttpHeaders

public void setBasicAuth(String username, String password, @Nullable Charset charset)

{
    setBasicAuth(encodeBasicAuth(username, password, charset));
}
org.springframework.http.HttpHeaders

public void setBearerAuth(String token)

{
    set(AUTHORIZATION, "Bearer " + token);
}
org.springframework.http.HttpHeaders

public void setCacheControl(CacheControl cacheControl)

{
    setOrRemove(CACHE_CONTROL, cacheControl.getHeaderValue());
}
org.springframework.http.HttpHeaders

public void setCacheControl(@Nullable String cacheControl)

{
    setOrRemove(CACHE_CONTROL, cacheControl);
}
org.springframework.http.HttpHeaders

public void setConnection(String connection)

{
    set(CONNECTION, connection);
}
org.springframework.http.HttpHeaders

public void setConnection(List<String> connection)

{
    set(CONNECTION, toCommaDelimitedString(connection));
}
org.springframework.http.HttpHeaders

public void setContentDisposition(ContentDisposition contentDisposition)

{
    set(CONTENT_DISPOSITION, contentDisposition.toString());
}
org.springframework.http.HttpHeaders

public void setContentDispositionFormData(String name, @Nullable String filename)

{
    Assert.notNull(name, "Name must not be null");
    ContentDisposition.Builder disposition = ContentDisposition.builder("form-data").name(name);
    if (filename != null) {
        disposition.filename(filename);
    } 
    setContentDisposition(disposition.build());
}
org.springframework.http.HttpHeaders

public void setContentLanguage(@Nullable Locale locale)

{
    setOrRemove(CONTENT_LANGUAGE, (locale != null ? locale.toLanguageTag() : null));
}
org.springframework.http.HttpHeaders

public void setContentLength(long contentLength)

{
    set(CONTENT_LENGTH, Long.toString(contentLength));
}
org.springframework.http.HttpHeaders

public void setDate(ZonedDateTime date)

{
    setZonedDateTime(DATE, date);
}
org.springframework.http.HttpHeaders

public void setDate(Instant date)

{
    setInstant(DATE, date);
}
org.springframework.http.HttpHeaders

public void setDate(long date)

{
    setDate(DATE, date);
}
org.springframework.http.HttpHeaders

public void setDate(String headerName, long date)

{
    setInstant(headerName, Instant.ofEpochMilli(date));
}
org.springframework.http.HttpHeaders

public void setExpires(ZonedDateTime expires)

{
    setZonedDateTime(EXPIRES, expires);
}
org.springframework.http.HttpHeaders

public void setExpires(Instant expires)

{
    setInstant(EXPIRES, expires);
}
org.springframework.http.HttpHeaders

public void setExpires(long expires)

{
    setDate(EXPIRES, expires);
}
org.springframework.http.HttpHeaders

public void setHost(@Nullable InetSocketAddress host)

{
    if (host != null) {
        String value = host.getHostString();
        int port = host.getPort();
        if (port != 0) {
            value = value + ":" + port;
        } 
        set(HOST, value);
    } else {
        remove(HOST, null);
    }
}
org.springframework.http.HttpHeaders

public void setIfMatch(String ifMatch)

{
    set(IF_MATCH, ifMatch);
}
org.springframework.http.HttpHeaders

public void setIfMatch(List<String> ifMatchList)

{
    set(IF_MATCH, toCommaDelimitedString(ifMatchList));
}
org.springframework.http.HttpHeaders

public void setIfModifiedSince(ZonedDateTime ifModifiedSince)

{
    setZonedDateTime(IF_MODIFIED_SINCE, ifModifiedSince.withZoneSameInstant(GMT));
}
org.springframework.http.HttpHeaders

public void setIfModifiedSince(Instant ifModifiedSince)

{
    setInstant(IF_MODIFIED_SINCE, ifModifiedSince);
}
org.springframework.http.HttpHeaders

public void setIfModifiedSince(long ifModifiedSince)

{
    setDate(IF_MODIFIED_SINCE, ifModifiedSince);
}
org.springframework.http.HttpHeaders

public void setIfNoneMatch(String ifNoneMatch)

{
    set(IF_NONE_MATCH, ifNoneMatch);
}
org.springframework.http.HttpHeaders

public void setIfNoneMatch(List<String> ifNoneMatchList)

{
    set(IF_NONE_MATCH, toCommaDelimitedString(ifNoneMatchList));
}
org.springframework.http.HttpHeaders

public void setIfUnmodifiedSince(ZonedDateTime ifUnmodifiedSince)

{
    setZonedDateTime(IF_UNMODIFIED_SINCE, ifUnmodifiedSince.withZoneSameInstant(GMT));
}
org.springframework.http.HttpHeaders

public void setIfUnmodifiedSince(Instant ifUnmodifiedSince)

{
    setInstant(IF_UNMODIFIED_SINCE, ifUnmodifiedSince);
}
org.springframework.http.HttpHeaders

public void setIfUnmodifiedSince(long ifUnmodifiedSince)

{
    setDate(IF_UNMODIFIED_SINCE, ifUnmodifiedSince);
}
org.springframework.http.HttpHeaders

public void setInstant(String headerName, Instant date)

{
    setZonedDateTime(headerName, ZonedDateTime.ofInstant(date, GMT));
}
org.springframework.http.HttpHeaders

public void setLastModified(ZonedDateTime lastModified)

{
    setZonedDateTime(LAST_MODIFIED, lastModified.withZoneSameInstant(GMT));
}
org.springframework.http.HttpHeaders

public void setLastModified(Instant lastModified)

{
    setInstant(LAST_MODIFIED, lastModified);
}
org.springframework.http.HttpHeaders

public void setLastModified(long lastModified)

{
    setDate(LAST_MODIFIED, lastModified);
}
org.springframework.http.HttpHeaders

public void setLocation(@Nullable URI location)

{
    setOrRemove(LOCATION, (location != null ? location.toASCIIString() : null));
}
org.springframework.http.HttpHeaders

public void setOrigin(@Nullable String origin)

{
    setOrRemove(ORIGIN, origin);
}
org.springframework.http.HttpHeaders

public void setPragma(@Nullable String pragma)

{
    setOrRemove(PRAGMA, pragma);
}
org.springframework.http.HttpHeaders

public void setRange(List<HttpRange> ranges)

{
    String value = HttpRange.toString(ranges);
    set(RANGE, value);
}
org.springframework.http.HttpHeaders

public void setUpgrade(@Nullable String upgrade)

{
    setOrRemove(UPGRADE, upgrade);
}
org.springframework.http.HttpHeaders

public void setVary(List<String> requestHeaders)

{
    set(VARY, toCommaDelimitedString(requestHeaders));
}
org.springframework.http.HttpHeaders

public void setZonedDateTime(String headerName, ZonedDateTime date)

{
    set(headerName, DATE_FORMATTER.format(date));
}
org.springframework.http.HttpHeaders

@Override public int size()

{
    return this.headers.size();
}
org.springframework.http.HttpHeaders

protected String toCommaDelimitedString(List<String> headerValues)

{
    StringJoiner joiner = new StringJoiner(", ");
    for (String val: headerValues) {
        if (val != null) {
            joiner.add(val);
        } 
    }
    return joiner.toString();
}
org.springframework.http.HttpHeaders

@Override public Map<String, String> toSingleValueMap()

{
    return this.headers.toSingleValueMap();
}
org.springframework.http.HttpHeaders

@Override public String toString()

{
    return formatHeaders(this.headers);
}
org.springframework.http.HttpHeaders

@Override public Collection<List<String>> values()

{
    return this.headers.values();
}
org.springframework.http.HttpHeaders

public static HttpHeaders writableHttpHeaders(HttpHeaders headers)

{
    Assert.notNull(headers, "HttpHeaders must not be null");
    if (headers == EMPTY) {
        return new HttpHeaders();
    } else if (headers instanceof ReadOnlyHttpHeaders) {
        return new HttpHeaders(headers.headers);
    } else {
        return headers;
    }
}

HttpInputMessage
inherit classes
  • HttpMessage

HttpLogging

org.springframework.http.HttpLogging

public static Log forLog(Log primaryLogger)

{
    return LogDelegateFactory.getCompositeLog(primaryLogger, fallbackLogger);
}
org.springframework.http.HttpLogging

public static Log forLogName(Class<?> primaryLoggerClass)

{
    Log primaryLogger = LogFactory.getLog(primaryLoggerClass);
    return forLog(primaryLogger);
}

HttpMessage

HttpMethod

enum values
  • GET
  • HEAD
  • POST
  • PUT
  • PATCH
  • DELETE
  • OPTIONS
  • TRACE
org.springframework.http

public boolean matches(String method)

{
    return (this == resolve(method));
}
org.springframework.http

@Nullable public static HttpMethod resolve(@Nullable String method)

{
    return (method != null ? mappings.get(method) : null);
}

HttpOutputMessage
inherit classes
  • HttpMessage

HttpRange

org.springframework.http.HttpRange

public static HttpRange createByteRange(long firstBytePos)

{
    return new ByteRange(firstBytePos, null);
}
org.springframework.http.HttpRange

public static HttpRange createByteRange(long firstBytePos, long lastBytePos)

{
    return new ByteRange(firstBytePos, lastBytePos);
}
org.springframework.http.HttpRange

public static HttpRange createSuffixRange(long suffixLength)

{
    return new SuffixByteRange(suffixLength);
}
org.springframework.http.HttpRange

public abstract long getRangeEnd(long length)

org.springframework.http.HttpRange

public abstract long getRangeStart(long length)

org.springframework.http.HttpRange

public static List<HttpRange> parseRanges(@Nullable String ranges)

{
    if (!StringUtils.hasLength(ranges)) {
        return Collections.emptyList();
    } 
    if (!ranges.startsWith(BYTE_RANGE_PREFIX)) {
        throw new IllegalArgumentException("Range '" + ranges + "' does not start with 'bytes='");
    } 
    ranges = ranges.substring(BYTE_RANGE_PREFIX.length());
    String[] tokens = StringUtils.tokenizeToStringArray(ranges, ",");
    if (tokens.length > MAX_RANGES) {
        throw new IllegalArgumentException("Too many ranges: " + tokens.length);
    } 
    List<HttpRange> result = new ArrayList<>(tokens.length);
    for (String token: tokens) {
        result.add(parseRange(token));
    }
    return result;
}
org.springframework.http.HttpRange

public static List<ResourceRegion> toResourceRegions(List<HttpRange> ranges, Resource resource)

{
    if (CollectionUtils.isEmpty(ranges)) {
        return Collections.emptyList();
    } 
    List<ResourceRegion> regions = new ArrayList<>(ranges.size());
    for (HttpRange range: ranges) {
        regions.add(range.toResourceRegion(resource));
    }
    if (ranges.size() > 1) {
        long length = getLengthFor(resource);
        long total = 0;
        for (ResourceRegion region: regions) {
            total += region.getCount();
        }
        if (total >= length) {
            throw new IllegalArgumentException("The sum of all ranges (" + total + ") should be less than the resource length (" + length + ")");
        } 
    } 
    return regions;
}

HttpRequest
inherit classes
  • HttpMessage

HttpStatus

enum values
  • CONTINUE
  • SWITCHING_PROTOCOLS
  • PROCESSING
  • CHECKPOINT
  • OK
  • CREATED
  • ACCEPTED
  • NON_AUTHORITATIVE_INFORMATION
  • NO_CONTENT
  • RESET_CONTENT
  • PARTIAL_CONTENT
  • MULTI_STATUS
  • ALREADY_REPORTED
  • IM_USED
  • MULTIPLE_CHOICES
  • MOVED_PERMANENTLY
  • FOUND
  • MOVED_TEMPORARILY
  • SEE_OTHER
  • NOT_MODIFIED
  • USE_PROXY
  • TEMPORARY_REDIRECT
  • PERMANENT_REDIRECT
  • BAD_REQUEST
  • UNAUTHORIZED
  • PAYMENT_REQUIRED
  • FORBIDDEN
  • NOT_FOUND
  • METHOD_NOT_ALLOWED
  • NOT_ACCEPTABLE
  • PROXY_AUTHENTICATION_REQUIRED
  • REQUEST_TIMEOUT
  • CONFLICT
  • GONE
  • LENGTH_REQUIRED
  • PRECONDITION_FAILED
  • PAYLOAD_TOO_LARGE
  • REQUEST_ENTITY_TOO_LARGE
  • URI_TOO_LONG
  • REQUEST_URI_TOO_LONG
  • UNSUPPORTED_MEDIA_TYPE
  • REQUESTED_RANGE_NOT_SATISFIABLE
  • EXPECTATION_FAILED
  • I_AM_A_TEAPOT
  • INSUFFICIENT_SPACE_ON_RESOURCE
  • METHOD_FAILURE
  • DESTINATION_LOCKED
  • UNPROCESSABLE_ENTITY
  • LOCKED
  • FAILED_DEPENDENCY
  • TOO_EARLY
  • UPGRADE_REQUIRED
  • PRECONDITION_REQUIRED
  • TOO_MANY_REQUESTS
  • REQUEST_HEADER_FIELDS_TOO_LARGE
  • UNAVAILABLE_FOR_LEGAL_REASONS
  • INTERNAL_SERVER_ERROR
  • NOT_IMPLEMENTED
  • BAD_GATEWAY
  • SERVICE_UNAVAILABLE
  • GATEWAY_TIMEOUT
  • HTTP_VERSION_NOT_SUPPORTED
  • VARIANT_ALSO_NEGOTIATES
  • INSUFFICIENT_STORAGE
  • LOOP_DETECTED
  • BANDWIDTH_LIMIT_EXCEEDED
  • NOT_EXTENDED
  • NETWORK_AUTHENTICATION_REQUIRED

Series

enum values
  • INFORMATIONAL
  • SUCCESSFUL
  • REDIRECTION
  • CLIENT_ERROR
  • SERVER_ERROR
org.springframework.http

@Nullable public static Series resolve(int statusCode)

{
    int seriesCode = statusCode / 100;
    for (Series series: values()) {
        if (series.value == seriesCode) {
            return series;
        } 
    }
    return null;
}
org.springframework.http

public int value()

{
    return this.value;
}
org.springframework.http

public static Series valueOf(HttpStatus status)

{
    return valueOf(status.value);
}
org.springframework.http

public String getReasonPhrase()

{
    return this.reasonPhrase;
}
org.springframework.http

public boolean is1xxInformational()

{
    return (series() == Series.INFORMATIONAL);
}
org.springframework.http

public boolean is2xxSuccessful()

{
    return (series() == Series.SUCCESSFUL);
}
org.springframework.http

public boolean is3xxRedirection()

{
    return (series() == Series.REDIRECTION);
}
org.springframework.http

public boolean is4xxClientError()

{
    return (series() == Series.CLIENT_ERROR);
}
org.springframework.http

public boolean is5xxServerError()

{
    return (series() == Series.SERVER_ERROR);
}
org.springframework.http

public boolean isError()

{
    return (is4xxClientError() || is5xxServerError());
}
org.springframework.http

@Nullable public static HttpStatus resolve(int statusCode)

{
    for (HttpStatus status: values()) {
        if (status.value == statusCode) {
            return status;
        } 
    }
    return null;
}
org.springframework.http

public Series series()

{
    return Series.valueOf(this);
}
org.springframework.http

@Override public String toString()

{
    return this.value + " " + name();
}
org.springframework.http

public int value()

{
    return this.value;
}

InvalidMediaTypeException
extends IllegalArgumentException

org.springframework.http.InvalidMediaTypeException

public InvalidMediaTypeException InvalidMediaTypeException(String mediaType, String message)

{
    super("Invalid media type \"" + mediaType + "\": " + message);
    this.mediaType = mediaType;
}
org.springframework.http.InvalidMediaTypeException

public String getMediaType()

{
    return this.mediaType;
}

MediaType
extends MimeType implements Serializable

org.springframework.http.MediaType

public static final MediaType ALL

org.springframework.http.MediaType

public static final String ALL_VALUE

org.springframework.http.MediaType

public static final MediaType APPLICATION_ATOM_XML

org.springframework.http.MediaType

public static final String APPLICATION_ATOM_XML_VALUE

org.springframework.http.MediaType

public static final MediaType APPLICATION_CBOR

org.springframework.http.MediaType

public static final String APPLICATION_CBOR_VALUE

org.springframework.http.MediaType

public static final MediaType APPLICATION_FORM_URLENCODED

org.springframework.http.MediaType

public static final String APPLICATION_FORM_URLENCODED_VALUE

org.springframework.http.MediaType

public static final MediaType APPLICATION_JSON

org.springframework.http.MediaType

@Deprecated public static final MediaType APPLICATION_JSON_UTF8

org.springframework.http.MediaType

@Deprecated public static final String APPLICATION_JSON_UTF8_VALUE

org.springframework.http.MediaType

public static final String APPLICATION_JSON_VALUE

org.springframework.http.MediaType

public static final MediaType APPLICATION_OCTET_STREAM

org.springframework.http.MediaType

public static final String APPLICATION_OCTET_STREAM_VALUE

org.springframework.http.MediaType

public static final MediaType APPLICATION_PDF

org.springframework.http.MediaType

public static final String APPLICATION_PDF_VALUE

org.springframework.http.MediaType

public static final MediaType APPLICATION_PROBLEM_JSON

org.springframework.http.MediaType

@Deprecated public static final MediaType APPLICATION_PROBLEM_JSON_UTF8

org.springframework.http.MediaType

@Deprecated public static final String APPLICATION_PROBLEM_JSON_UTF8_VALUE

org.springframework.http.MediaType

public static final String APPLICATION_PROBLEM_JSON_VALUE

org.springframework.http.MediaType

public static final MediaType APPLICATION_PROBLEM_XML

org.springframework.http.MediaType

public static final String APPLICATION_PROBLEM_XML_VALUE

org.springframework.http.MediaType

public static final MediaType APPLICATION_RSS_XML

org.springframework.http.MediaType

public static final String APPLICATION_RSS_XML_VALUE

org.springframework.http.MediaType

public static final MediaType APPLICATION_STREAM_JSON

org.springframework.http.MediaType

public static final String APPLICATION_STREAM_JSON_VALUE

org.springframework.http.MediaType

public static final MediaType APPLICATION_XHTML_XML

org.springframework.http.MediaType

public static final String APPLICATION_XHTML_XML_VALUE

org.springframework.http.MediaType

public static final MediaType APPLICATION_XML

org.springframework.http.MediaType

public static final String APPLICATION_XML_VALUE

org.springframework.http.MediaType

public static final MediaType IMAGE_GIF

org.springframework.http.MediaType

public static final String IMAGE_GIF_VALUE

org.springframework.http.MediaType

public static final MediaType IMAGE_JPEG

org.springframework.http.MediaType

public static final String IMAGE_JPEG_VALUE

org.springframework.http.MediaType

public static final MediaType IMAGE_PNG

org.springframework.http.MediaType

public static final String IMAGE_PNG_VALUE

org.springframework.http.MediaType

public static final MediaType MULTIPART_FORM_DATA

org.springframework.http.MediaType

public static final String MULTIPART_FORM_DATA_VALUE

org.springframework.http.MediaType

public static final MediaType MULTIPART_MIXED

org.springframework.http.MediaType

public static final String MULTIPART_MIXED_VALUE

org.springframework.http.MediaType

public MediaType MediaType(String type)

{
    super(type);
}
org.springframework.http.MediaType

public MediaType MediaType(String type, String subtype)

{
    super(type, subtype, Collections.emptyMap());
}
org.springframework.http.MediaType

public MediaType MediaType(String type, String subtype, Charset charset)

{
    super(type, subtype, charset);
}
org.springframework.http.MediaType

public MediaType MediaType(String type, String subtype, double qualityValue)

{
    this(type, subtype, Collections.singletonMap(PARAM_QUALITY_FACTOR, Double.toString(qualityValue)));
}
org.springframework.http.MediaType

public MediaType MediaType(MediaType other, Charset charset)

{
    super(other, charset);
}
org.springframework.http.MediaType

public MediaType MediaType(MediaType other, @Nullable Map<String, String> parameters)

{
    super(other.getType(), other.getSubtype(), parameters);
}
org.springframework.http.MediaType

public MediaType MediaType(String type, String subtype, @Nullable Map<String, String> parameters)

{
    super(type, subtype, parameters);
}
org.springframework.http.MediaType

public static final Comparator<MediaType> QUALITY_VALUE_COMPARATOR

org.springframework.http.MediaType

public static final Comparator<MediaType> SPECIFICITY_COMPARATOR

org.springframework.http.MediaType

public static final MediaType TEXT_EVENT_STREAM

org.springframework.http.MediaType

public static final String TEXT_EVENT_STREAM_VALUE

org.springframework.http.MediaType

public static final MediaType TEXT_HTML

org.springframework.http.MediaType

public static final String TEXT_HTML_VALUE

org.springframework.http.MediaType

public static final MediaType TEXT_MARKDOWN

org.springframework.http.MediaType

public static final String TEXT_MARKDOWN_VALUE

org.springframework.http.MediaType

public static final MediaType TEXT_PLAIN

org.springframework.http.MediaType

public static final String TEXT_PLAIN_VALUE

org.springframework.http.MediaType

public static final MediaType TEXT_XML

org.springframework.http.MediaType

public static final String TEXT_XML_VALUE

org.springframework.http.MediaType

public static MediaType asMediaType(MimeType mimeType)

{
    if (mimeType instanceof MediaType) {
        return (MediaType)mimeType;
    } 
    return new MediaType(mimeType.getType(), mimeType.getSubtype(), mimeType.getParameters());
}
org.springframework.http.MediaType

public static List<MediaType> asMediaTypes(List<MimeType> mimeTypes)

{
    List<MediaType> mediaTypes = new ArrayList<>(mimeTypes.size());
    for (MimeType mimeType: mimeTypes) {
        mediaTypes.add(MediaType.asMediaType(mimeType));
    }
    return mediaTypes;
}
org.springframework.http.MediaType

public MediaType copyQualityValue(MediaType mediaType)

{
    if (!mediaType.getParameters().containsKey(PARAM_QUALITY_FACTOR)) {
        return this;
    } 
    Map<String, String> params = new LinkedHashMap<>(getParameters());
    params.put(PARAM_QUALITY_FACTOR, mediaType.getParameters().get(PARAM_QUALITY_FACTOR));
    return new MediaType(this, params);
}
org.springframework.http.MediaType

public boolean includes(@Nullable MediaType other)

{
    return super.includes(other);
}
org.springframework.http.MediaType

public boolean isCompatibleWith(@Nullable MediaType other)

{
    return super.isCompatibleWith(other);
}
org.springframework.http.MediaType

public static List<MediaType> parseMediaTypes(@Nullable String mediaTypes)

{
    if (!StringUtils.hasLength(mediaTypes)) {
        return Collections.emptyList();
    } 
    List<String> tokenizedTypes = MimeTypeUtils.tokenize(mediaTypes);
    List<MediaType> result = new ArrayList<>(tokenizedTypes.size());
    for (String type: tokenizedTypes) {
        if (StringUtils.hasText(type)) {
            result.add(parseMediaType(type));
        } 
    }
    return result;
}
org.springframework.http.MediaType

public static List<MediaType> parseMediaTypes(@Nullable List<String> mediaTypes)

{
    if (CollectionUtils.isEmpty(mediaTypes)) {
        return Collections.emptyList();
    } else if (mediaTypes.size() == 1) {
        return parseMediaTypes(mediaTypes.get(0));
    } else {
        List<MediaType> result = new ArrayList<>(8);
        for (String mediaType: mediaTypes) {
            result.addAll(parseMediaTypes(mediaType));
        }
        return result;
    }
}
org.springframework.http.MediaType

public MediaType removeQualityValue()

{
    if (!getParameters().containsKey(PARAM_QUALITY_FACTOR)) {
        return this;
    } 
    Map<String, String> params = new LinkedHashMap<>(getParameters());
    params.remove(PARAM_QUALITY_FACTOR);
    return new MediaType(this, params);
}
org.springframework.http.MediaType

public static void sortByQualityValue(List<MediaType> mediaTypes)

{
    Assert.notNull(mediaTypes, "'mediaTypes' must not be null");
    if (mediaTypes.size() > 1) {
        mediaTypes.sort(QUALITY_VALUE_COMPARATOR);
    } 
}
org.springframework.http.MediaType

public static void sortBySpecificity(List<MediaType> mediaTypes)

{
    Assert.notNull(mediaTypes, "'mediaTypes' must not be null");
    if (mediaTypes.size() > 1) {
        mediaTypes.sort(SPECIFICITY_COMPARATOR);
    } 
}
org.springframework.http.MediaType

public static String toString(Collection<MediaType> mediaTypes)

{
    return MimeTypeUtils.toString(mediaTypes);
}
org.springframework.http.MediaType

public static MediaType valueOf(String value)

{
    return parseMediaType(value);
}

MediaTypeEditor
extends PropertyEditorSupport

org.springframework.http.MediaTypeEditor

@Override public String getAsText()

{
    MediaType mediaType = (MediaType)getValue();
    return (mediaType != null ? mediaType.toString() : "");
}
org.springframework.http.MediaTypeEditor

@Override public void setAsText(String text)

{
    if (StringUtils.hasText(text)) {
        setValue(MediaType.parseMediaType(text));
    } else {
        setValue(null);
    }
}

MediaTypeFactory

org.springframework.http.MediaTypeFactory

public static Optional<MediaType> getMediaType(@Nullable Resource resource)

{
    return Optional.ofNullable(resource).map(Resource::getFilename).flatMap(MediaTypeFactory::getMediaType);
}
org.springframework.http.MediaTypeFactory

public static Optional<MediaType> getMediaType(@Nullable String filename)

{
    return getMediaTypes(filename).stream().findFirst();
}

ReactiveHttpInputMessage
inherit classes
  • HttpMessage

ReactiveHttpOutputMessage
inherit classes
  • HttpMessage

ReadOnlyHttpHeaders
extends HttpHeaders

org.springframework.http.ReadOnlyHttpHeaders

@Override public void add(String headerName, @Nullable String headerValue)

{
    throw new UnsupportedOperationException();
}
org.springframework.http.ReadOnlyHttpHeaders

@Override public void addAll(String key, List<?> values)

{
    throw new UnsupportedOperationException();
}
org.springframework.http.ReadOnlyHttpHeaders

@Override public void addAll(MultiValueMap<String, String> values)

{
    throw new UnsupportedOperationException();
}
org.springframework.http.ReadOnlyHttpHeaders

@Override public void clear()

{
    throw new UnsupportedOperationException();
}
org.springframework.http.ReadOnlyHttpHeaders

@Override public List<String> get(Object key)

{
    List<String> values = this.headers.get(key);
    return (values != null ? Collections.unmodifiableList(values) : null);
}
org.springframework.http.ReadOnlyHttpHeaders

@Override public Set<String> keySet()

{
    return Collections.unmodifiableSet(this.headers.keySet());
}
org.springframework.http.ReadOnlyHttpHeaders

@Override public List<String> put(String key, List<String> value)

{
    throw new UnsupportedOperationException();
}
org.springframework.http.ReadOnlyHttpHeaders

@Override public void putAll(Map<?, ?> map)

{
    throw new UnsupportedOperationException();
}
org.springframework.http.ReadOnlyHttpHeaders

@Override public List<String> remove(Object key)

{
    throw new UnsupportedOperationException();
}
org.springframework.http.ReadOnlyHttpHeaders

@Override public void set(String headerName, @Nullable String headerValue)

{
    throw new UnsupportedOperationException();
}
org.springframework.http.ReadOnlyHttpHeaders

@Override public void setAll(Map<String, String> values)

{
    throw new UnsupportedOperationException();
}
org.springframework.http.ReadOnlyHttpHeaders

@Override public Map<String, String> toSingleValueMap()

{
    return Collections.unmodifiableMap(this.headers.toSingleValueMap());
}
org.springframework.http.ReadOnlyHttpHeaders

@Override public Collection<List<String>> values()

{
    return Collections.unmodifiableCollection(this.headers.values());
}

RequestEntity<T>
extends HttpEntity<T>

BodyBuilder
inherit classes
  • HeadersBuilder<BodyBuilder>
HeadersBuilder
org.springframework.http.RequestEntity

public RequestEntity RequestEntity(HttpMethod method, URI url)

{
    this(null, null, method, url, null);
}
org.springframework.http.RequestEntity

public RequestEntity RequestEntity(@Nullable T body, HttpMethod method, URI url)

{
    this(body, null, method, url, null);
}
org.springframework.http.RequestEntity

public RequestEntity RequestEntity(@Nullable T body, HttpMethod method, URI url, Type type)

{
    this(body, null, method, url, type);
}
org.springframework.http.RequestEntity

public RequestEntity RequestEntity(MultiValueMap<String, String> headers, HttpMethod method, URI url)

{
    this(null, headers, method, url, null);
}
org.springframework.http.RequestEntity

public RequestEntity RequestEntity(@Nullable T body, @Nullable MultiValueMap<String, String> headers, @Nullable HttpMethod method, URI url)

{
    this(body, headers, method, url, null);
}
org.springframework.http.RequestEntity

public RequestEntity RequestEntity(@Nullable T body, @Nullable MultiValueMap<String, String> headers, @Nullable HttpMethod method, URI url, @Nullable Type type)

{
    super(body, headers);
    this.method = method;
    this.url = url;
    this.type = type;
}
org.springframework.http.RequestEntity

public static HeadersBuilder<?> delete(URI url)

{
    return method(HttpMethod.DELETE, url);
}
org.springframework.http.RequestEntity

@Override public boolean equals(@Nullable Object other)

{
    if (this == other) {
        return true;
    } 
    if (!super.equals(other)) {
        return false;
    } 
    RequestEntity<?> otherEntity = (RequestEntity<?>)other;
    return (ObjectUtils.nullSafeEquals(getMethod(), otherEntity.getMethod()) && ObjectUtils.nullSafeEquals(getUrl(), otherEntity.getUrl()));
}
org.springframework.http.RequestEntity

public static HeadersBuilder<?> get(URI url)

{
    return method(HttpMethod.GET, url);
}
org.springframework.http.RequestEntity

@Nullable public HttpMethod getMethod()

{
    return this.method;
}
org.springframework.http.RequestEntity

@Nullable public Type getType()

{
    if (this.type == null) {
        T body = getBody();
        if (body != null) {
            return body.getClass();
        } 
    } 
    return this.type;
}
org.springframework.http.RequestEntity

public URI getUrl()

{
    return this.url;
}
org.springframework.http.RequestEntity

public static HeadersBuilder<?> head(URI url)

{
    return method(HttpMethod.HEAD, url);
}
org.springframework.http.RequestEntity

public static BodyBuilder method(HttpMethod method, URI url)

{
    return new DefaultBodyBuilder(method, url);
}
org.springframework.http.RequestEntity

public static HeadersBuilder<?> options(URI url)

{
    return method(HttpMethod.OPTIONS, url);
}
org.springframework.http.RequestEntity

public static BodyBuilder patch(URI url)

{
    return method(HttpMethod.PATCH, url);
}
org.springframework.http.RequestEntity

public static BodyBuilder post(URI url)

{
    return method(HttpMethod.POST, url);
}
org.springframework.http.RequestEntity

public static BodyBuilder put(URI url)

{
    return method(HttpMethod.PUT, url);
}

ResponseCookie
extends HttpCookie

ResponseCookieBuilder
org.springframework.http.ResponseCookie

@Override public boolean equals(@Nullable Object other)

{
    if (this == other) {
        return true;
    } 
    if (!(other instanceof ResponseCookie)) {
        return false;
    } 
    ResponseCookie otherCookie = (ResponseCookie)other;
    return (getName().equalsIgnoreCase(otherCookie.getName()) && ObjectUtils.nullSafeEquals(this.path, otherCookie.getPath()) && ObjectUtils.nullSafeEquals(this.domain, otherCookie.getDomain()));
}
org.springframework.http.ResponseCookie

public static ResponseCookieBuilder from(final String name, final String value)

{
    return new ResponseCookieBuilder() {
        private Duration maxAge = Duration.ofSeconds(-1);
        @Nullable
        private String domain;
        @Nullable
        private String path;
        private boolean secure;
        private boolean httpOnly;
        @Nullable
        private String sameSite;
        @Override
        public ResponseCookieBuilder maxAge(DurationmaxAge) {
            this.maxAge = maxAge;
            return this;
        }
        @Override
        public ResponseCookieBuilder maxAge(longmaxAgeSeconds) {
            this.maxAge = maxAgeSeconds >= 0 ? Duration.ofSeconds(maxAgeSeconds) : Duration.ofSeconds(-1);
            return this;
        }
        @Override
        public ResponseCookieBuilder domain(Stringdomain) {
            this.domain = domain;
            return this;
        }
        @Override
        public ResponseCookieBuilder path(Stringpath) {
            this.path = path;
            return this;
        }
        @Override
        public ResponseCookieBuilder secure(booleansecure) {
            this.secure = secure;
            return this;
        }
        @Override
        public ResponseCookieBuilder httpOnly(booleanhttpOnly) {
            this.httpOnly = httpOnly;
            return this;
        }
        @Override
        public ResponseCookieBuilder sameSite(@NullableStringsameSite) {
            this.sameSite = sameSite;
            return this;
        }
        @Override
        public ResponseCookie build() {
            return new ResponseCookie(name, value, this.maxAge, this.domain, this.path, this.secure, this.httpOnly, this.sameSite);
        }
    };
}
org.springframework.http.ResponseCookie

@Nullable public String getDomain()

{
    return this.domain;
}
org.springframework.http.ResponseCookie

public Duration getMaxAge()

{
    return this.maxAge;
}
org.springframework.http.ResponseCookie

@Nullable public String getPath()

{
    return this.path;
}
org.springframework.http.ResponseCookie

@Nullable public String getSameSite()

{
    return this.sameSite;
}
org.springframework.http.ResponseCookie

public boolean isHttpOnly()

{
    return this.httpOnly;
}
org.springframework.http.ResponseCookie

public boolean isSecure()

{
    return this.secure;
}

ResponseEntity<T>
extends HttpEntity<T>

BodyBuilder
inherit classes
  • HeadersBuilder<BodyBuilder>
HeadersBuilder
org.springframework.http.ResponseEntity

public ResponseEntity ResponseEntity(HttpStatus status)

{
    this(null, null, status);
}
org.springframework.http.ResponseEntity

public ResponseEntity ResponseEntity(@Nullable T body, HttpStatus status)

{
    this(body, null, status);
}
org.springframework.http.ResponseEntity

public ResponseEntity ResponseEntity(MultiValueMap<String, String> headers, HttpStatus status)

{
    this(null, headers, status);
}
org.springframework.http.ResponseEntity

public ResponseEntity ResponseEntity(@Nullable T body, @Nullable MultiValueMap<String, String> headers, HttpStatus status)

{
    super(body, headers);
    Assert.notNull(status, "HttpStatus must not be null");
    this.status = status;
}
org.springframework.http.ResponseEntity

public static BodyBuilder accepted()

{
    return status(HttpStatus.ACCEPTED);
}
org.springframework.http.ResponseEntity

public static BodyBuilder badRequest()

{
    return status(HttpStatus.BAD_REQUEST);
}
org.springframework.http.ResponseEntity

public static BodyBuilder created(URI location)

{
    BodyBuilder builder = status(HttpStatus.CREATED);
    return builder.location(location);
}
org.springframework.http.ResponseEntity

@Override public boolean equals(@Nullable Object other)

{
    if (this == other) {
        return true;
    } 
    if (!super.equals(other)) {
        return false;
    } 
    ResponseEntity<?> otherEntity = (ResponseEntity<?>)other;
    return ObjectUtils.nullSafeEquals(this.status, otherEntity.status);
}
org.springframework.http.ResponseEntity

@Override public int hashCode()

{
    return (29 * super.hashCode() + ObjectUtils.nullSafeHashCode(this.status));
}
org.springframework.http.ResponseEntity

public static HeadersBuilder<?> noContent()

{
    return status(HttpStatus.NO_CONTENT);
}
org.springframework.http.ResponseEntity

public static HeadersBuilder<?> notFound()

{
    return status(HttpStatus.NOT_FOUND);
}
org.springframework.http.ResponseEntity

<T>public static ResponseEntity<T> of(Optional<T> body)

{
    Assert.notNull(body, "Body must not be null");
    return body.map(ResponseEntity::ok).orElse(notFound().build());
}
org.springframework.http.ResponseEntity

public static BodyBuilder ok()

{
    return status(HttpStatus.OK);
}
org.springframework.http.ResponseEntity

<T>public static ResponseEntity<T> ok(T body)

{
    BodyBuilder builder = ok();
    return builder.body(body);
}
org.springframework.http.ResponseEntity

public static BodyBuilder status(HttpStatus status)

{
    Assert.notNull(status, "HttpStatus must not be null");
    return new DefaultBuilder(status);
}
org.springframework.http.ResponseEntity

public static BodyBuilder status(int status)

{
    return new DefaultBuilder(status);
}
org.springframework.http.ResponseEntity

@Override public String toString()

{
    StringBuilder builder = new StringBuilder("<");
    builder.append(this.status.toString());
    if (this.status instanceof HttpStatus) {
        builder.append(' ');
        builder.append(((HttpStatus)this.status).getReasonPhrase());
    } 
    builder.append(',');
    T body = getBody();
    HttpHeaders headers = getHeaders();
    if (body != null) {
        builder.append(body);
        builder.append(',');
    } 
    builder.append(headers);
    builder.append('>');
    return builder.toString();
}
org.springframework.http.ResponseEntity

public static BodyBuilder unprocessableEntity()

{
    return status(HttpStatus.UNPROCESSABLE_ENTITY);
}

StreamingHttpOutputMessage
inherit classes
  • HttpOutputMessage

ZeroCopyHttpOutputMessage
inherit classes
  • ReactiveHttpOutputMessage

AbstractAsyncClientHttpRequest
implements AsyncClientHttpRequest

org.springframework.http.client.AbstractAsyncClientHttpRequest

protected void assertNotExecuted()

{
    Assert.state(!this.executed, "ClientHttpRequest already executed");
}
org.springframework.http.client.AbstractAsyncClientHttpRequest

@Override public ListenableFuture<ClientHttpResponse> executeAsync()

{
    assertNotExecuted();
    ListenableFuture<ClientHttpResponse> result = executeInternal(this.headers);
    this.executed = true;
    return result;
}
org.springframework.http.client.AbstractAsyncClientHttpRequest

protected abstract ListenableFuture<ClientHttpResponse> executeInternal(HttpHeaders headers)

org.springframework.http.client.AbstractAsyncClientHttpRequest

@Override public final OutputStream getBody()

{
    assertNotExecuted();
    return getBodyInternal(this.headers);
}
org.springframework.http.client.AbstractAsyncClientHttpRequest

protected abstract OutputStream getBodyInternal(HttpHeaders headers)

org.springframework.http.client.AbstractAsyncClientHttpRequest

@Override public final HttpHeaders getHeaders()

{
    return (this.executed ? HttpHeaders.readOnlyHttpHeaders(this.headers) : this.headers);
}

AbstractBufferingAsyncClientHttpRequest
extends AbstractAsyncClientHttpRequest

org.springframework.http.client.AbstractBufferingAsyncClientHttpRequest

@Override protected ListenableFuture<ClientHttpResponse> executeInternal(HttpHeaders headers)

{
    byte[] bytes = this.bufferedOutput.toByteArray();
    if (headers.getContentLength() < 0) {
        headers.setContentLength(bytes.length);
    } 
    ListenableFuture<ClientHttpResponse> result = executeInternal(headers, bytes);
    this.bufferedOutput = new ByteArrayOutputStream(0);
    return result;
}
org.springframework.http.client.AbstractBufferingAsyncClientHttpRequest

protected abstract ListenableFuture<ClientHttpResponse> executeInternal(HttpHeaders headers, byte[] bufferedOutput)

org.springframework.http.client.AbstractBufferingAsyncClientHttpRequest

@Override protected OutputStream getBodyInternal(HttpHeaders headers)

{
    return this.bufferedOutput;
}

AbstractBufferingClientHttpRequest
extends AbstractClientHttpRequest

org.springframework.http.client.AbstractBufferingClientHttpRequest

@Override protected ClientHttpResponse executeInternal(HttpHeaders headers)

{
    byte[] bytes = this.bufferedOutput.toByteArray();
    if (headers.getContentLength() < 0) {
        headers.setContentLength(bytes.length);
    } 
    ClientHttpResponse result = executeInternal(headers, bytes);
    this.bufferedOutput = new ByteArrayOutputStream(0);
    return result;
}
org.springframework.http.client.AbstractBufferingClientHttpRequest

protected abstract ClientHttpResponse executeInternal(HttpHeaders headers, byte[] bufferedOutput)

org.springframework.http.client.AbstractBufferingClientHttpRequest

@Override protected OutputStream getBodyInternal(HttpHeaders headers)

{
    return this.bufferedOutput;
}

AbstractClientHttpRequest
implements ClientHttpRequest

org.springframework.http.client.AbstractClientHttpRequest

protected void assertNotExecuted()

{
    Assert.state(!this.executed, "ClientHttpRequest already executed");
}
org.springframework.http.client.AbstractClientHttpRequest

@Override public final ClientHttpResponse execute()

{
    assertNotExecuted();
    ClientHttpResponse result = executeInternal(this.headers);
    this.executed = true;
    return result;
}
org.springframework.http.client.AbstractClientHttpRequest

protected abstract ClientHttpResponse executeInternal(HttpHeaders headers)

org.springframework.http.client.AbstractClientHttpRequest

@Override public final OutputStream getBody()

{
    assertNotExecuted();
    return getBodyInternal(this.headers);
}
org.springframework.http.client.AbstractClientHttpRequest

protected abstract OutputStream getBodyInternal(HttpHeaders headers)

org.springframework.http.client.AbstractClientHttpRequest

@Override public final HttpHeaders getHeaders()

{
    return (this.executed ? HttpHeaders.readOnlyHttpHeaders(this.headers) : this.headers);
}

AbstractClientHttpRequestFactoryWrapper
implements ClientHttpRequestFactory

org.springframework.http.client.AbstractClientHttpRequestFactoryWrapper

protected AbstractClientHttpRequestFactoryWrapper AbstractClientHttpRequestFactoryWrapper(ClientHttpRequestFactory requestFactory)

{
    Assert.notNull(requestFactory, "ClientHttpRequestFactory must not be null");
    this.requestFactory = requestFactory;
}
org.springframework.http.client.AbstractClientHttpRequestFactoryWrapper

@Override public final ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod)

{
    return createRequest(uri, httpMethod, this.requestFactory);
}
org.springframework.http.client.AbstractClientHttpRequestFactoryWrapper

protected abstract ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod, ClientHttpRequestFactory requestFactory)


AbstractClientHttpResponse
implements ClientHttpResponse

org.springframework.http.client.AbstractClientHttpResponse

@Override public HttpStatus getStatusCode()

{
    return HttpStatus.valueOf(getRawStatusCode());
}

AsyncClientHttpRequest
inherit classes
  • HttpRequest
  • HttpOutputMessage

AsyncClientHttpRequestExecution

AsyncClientHttpRequestFactory

AsyncClientHttpRequestInterceptor

BufferingClientHttpRequestFactory
extends AbstractClientHttpRequestFactoryWrapper

org.springframework.http.client.BufferingClientHttpRequestFactory

public BufferingClientHttpRequestFactory BufferingClientHttpRequestFactory(ClientHttpRequestFactory requestFactory)

{
    super(requestFactory);
}
org.springframework.http.client.BufferingClientHttpRequestFactory

@Override protected ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod, ClientHttpRequestFactory requestFactory)

{
    ClientHttpRequest request = requestFactory.createRequest(uri, httpMethod);
    if (shouldBuffer(uri, httpMethod)) {
        return new BufferingClientHttpRequestWrapper(request);
    } else {
        return request;
    }
}
org.springframework.http.client.BufferingClientHttpRequestFactory

protected boolean shouldBuffer(URI uri, HttpMethod httpMethod)

{
    return true;
}

BufferingClientHttpRequestWrapper
extends AbstractBufferingClientHttpRequest

org.springframework.http.client.BufferingClientHttpRequestWrapper

@Override protected ClientHttpResponse executeInternal(HttpHeaders headers, byte[] bufferedOutput)

{
    this.request.getHeaders().putAll(headers);
    StreamUtils.copy(bufferedOutput, this.request.getBody());
    ClientHttpResponse response = this.request.execute();
    return new BufferingClientHttpResponseWrapper(response);
}
org.springframework.http.client.BufferingClientHttpRequestWrapper

@Override @Nullable public HttpMethod getMethod()

{
    return this.request.getMethod();
}
org.springframework.http.client.BufferingClientHttpRequestWrapper

@Override public String getMethodValue()

{
    return this.request.getMethodValue();
}
org.springframework.http.client.BufferingClientHttpRequestWrapper

@Override public URI getURI()

{
    return this.request.getURI();
}

BufferingClientHttpResponseWrapper
implements ClientHttpResponse

org.springframework.http.client.BufferingClientHttpResponseWrapper

@Override public void close()

{
    this.response.close();
}
org.springframework.http.client.BufferingClientHttpResponseWrapper

@Override public InputStream getBody()

{
    if (this.body == null) {
        this.body = StreamUtils.copyToByteArray(this.response.getBody());
    } 
    return new ByteArrayInputStream(this.body);
}
org.springframework.http.client.BufferingClientHttpResponseWrapper

@Override public HttpHeaders getHeaders()

{
    return this.response.getHeaders();
}
org.springframework.http.client.BufferingClientHttpResponseWrapper

@Override public int getRawStatusCode()

{
    return this.response.getRawStatusCode();
}
org.springframework.http.client.BufferingClientHttpResponseWrapper

@Override public HttpStatus getStatusCode()

{
    return this.response.getStatusCode();
}
org.springframework.http.client.BufferingClientHttpResponseWrapper

@Override public String getStatusText()

{
    return this.response.getStatusText();
}

ClientHttpRequest
inherit classes
  • HttpRequest
  • HttpOutputMessage

ClientHttpRequestExecution

ClientHttpRequestFactory

ClientHttpRequestInitializer

ClientHttpRequestInterceptor

ClientHttpResponse
inherit classes
  • HttpInputMessage
  • Closeable

HttpComponentsAsyncClientHttpRequest
extends AbstractBufferingAsyncClientHttpRequest

org.springframework.http.client.HttpComponentsAsyncClientHttpRequest

@Override protected ListenableFuture<ClientHttpResponse> executeInternal(HttpHeaders headers, byte[] bufferedOutput)

{
    HttpComponentsClientHttpRequest.addHeaders(this.httpRequest, headers);
    if (this.httpRequest instanceof HttpEntityEnclosingRequest) {
        HttpEntityEnclosingRequest entityEnclosingRequest = (HttpEntityEnclosingRequest)this.httpRequest;
        HttpEntity requestEntity = new NByteArrayEntity(bufferedOutput);
        entityEnclosingRequest.setEntity(requestEntity);
    } 
    HttpResponseFutureCallback callback = new HttpResponseFutureCallback(this.httpRequest);
    Future<HttpResponse> futureResponse = this.httpClient.execute(this.httpRequest, this.httpContext, callback);
    return new ClientHttpResponseFuture(futureResponse, callback);
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequest

@Override public String getMethodValue()

{
    return this.httpRequest.getMethod();
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequest

@Override public URI getURI()

{
    return this.httpRequest.getURI();
}

HttpComponentsAsyncClientHttpRequestFactory
extends HttpComponentsClientHttpRequestFactory implements AsyncClientHttpRequestFactory, InitializingBean

org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory

public HttpComponentsAsyncClientHttpRequestFactory HttpComponentsAsyncClientHttpRequestFactory()

{
    super();
    this.asyncClient = HttpAsyncClients.createSystem();
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory

public HttpComponentsAsyncClientHttpRequestFactory HttpComponentsAsyncClientHttpRequestFactory(HttpAsyncClient asyncClient)

{
    super();
    this.asyncClient = asyncClient;
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory

public HttpComponentsAsyncClientHttpRequestFactory HttpComponentsAsyncClientHttpRequestFactory(CloseableHttpAsyncClient asyncClient)

{
    super();
    this.asyncClient = asyncClient;
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory

public HttpComponentsAsyncClientHttpRequestFactory HttpComponentsAsyncClientHttpRequestFactory(HttpClient httpClient, HttpAsyncClient asyncClient)

{
    super(httpClient);
    this.asyncClient = asyncClient;
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory

public HttpComponentsAsyncClientHttpRequestFactory HttpComponentsAsyncClientHttpRequestFactory(CloseableHttpClient httpClient, CloseableHttpAsyncClient asyncClient)

{
    super(httpClient);
    this.asyncClient = asyncClient;
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory

@Override public void afterPropertiesSet()

{
    startAsyncClient();
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory

@Override public AsyncClientHttpRequest createAsyncRequest(URI uri, HttpMethod httpMethod)

{
    HttpAsyncClient client = startAsyncClient();
    HttpUriRequest httpRequest = createHttpUriRequest(httpMethod, uri);
    postProcessHttpRequest(httpRequest);
    HttpContext context = createHttpContext(httpMethod, uri);
    if (context == null) {
        context = HttpClientContext.create();
    } 
    if (context.getAttribute(HttpClientContext.REQUEST_CONFIG) == null) {
        RequestConfig config = null;
        if (httpRequest instanceof Configurable) {
            config = ((Configurable)httpRequest).getConfig();
        } 
        if (config == null) {
            config = createRequestConfig(client);
        } 
        if (config != null) {
            context.setAttribute(HttpClientContext.REQUEST_CONFIG, config);
        } 
    } 
    return new HttpComponentsAsyncClientHttpRequest(client, httpRequest, context);
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory

@Override public void destroy()

{
    try {
        super.destroy();
    } finally {
        HttpAsyncClient asyncClient = getAsyncClient();
        if (asyncClient instanceof Closeable) {
            ((Closeable)asyncClient).close();
        } 
    }
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory

public HttpAsyncClient getAsyncClient()

{
    return this.asyncClient;
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory

@Deprecated public CloseableHttpAsyncClient getHttpAsyncClient()

{
    Assert.state(this.asyncClient instanceof CloseableHttpAsyncClient, "No CloseableHttpAsyncClient - use getAsyncClient() instead");
    return (CloseableHttpAsyncClient)this.asyncClient;
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory

public void setAsyncClient(HttpAsyncClient asyncClient)

{
    Assert.notNull(asyncClient, "HttpAsyncClient must not be null");
    this.asyncClient = asyncClient;
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory

@Deprecated public void setHttpAsyncClient(CloseableHttpAsyncClient asyncClient)

{
    this.asyncClient = asyncClient;
}

HttpComponentsAsyncClientHttpResponse
extends AbstractClientHttpResponse

org.springframework.http.client.HttpComponentsAsyncClientHttpResponse

@Override public void close()

{
}
org.springframework.http.client.HttpComponentsAsyncClientHttpResponse

@Override public InputStream getBody()

{
    HttpEntity entity = this.httpResponse.getEntity();
    return (entity != null ? entity.getContent() : StreamUtils.emptyInput());
}
org.springframework.http.client.HttpComponentsAsyncClientHttpResponse

@Override public HttpHeaders getHeaders()

{
    if (this.headers == null) {
        this.headers = new HttpHeaders();
        for (Header header: this.httpResponse.getAllHeaders()) {
            this.headers.add(header.getName(), header.getValue());
        }
    } 
    return this.headers;
}
org.springframework.http.client.HttpComponentsAsyncClientHttpResponse

@Override public int getRawStatusCode()

{
    return this.httpResponse.getStatusLine().getStatusCode();
}
org.springframework.http.client.HttpComponentsAsyncClientHttpResponse

@Override public String getStatusText()

{
    return this.httpResponse.getStatusLine().getReasonPhrase();
}

HttpComponentsClientHttpRequest
extends AbstractBufferingClientHttpRequest

org.springframework.http.client.HttpComponentsClientHttpRequest

@Override protected ClientHttpResponse executeInternal(HttpHeaders headers, byte[] bufferedOutput)

{
    addHeaders(this.httpRequest, headers);
    if (this.httpRequest instanceof HttpEntityEnclosingRequest) {
        HttpEntityEnclosingRequest entityEnclosingRequest = (HttpEntityEnclosingRequest)this.httpRequest;
        HttpEntity requestEntity = new ByteArrayEntity(bufferedOutput);
        entityEnclosingRequest.setEntity(requestEntity);
    } 
    HttpResponse httpResponse = this.httpClient.execute(this.httpRequest, this.httpContext);
    return new HttpComponentsClientHttpResponse(httpResponse);
}
org.springframework.http.client.HttpComponentsClientHttpRequest

@Override public String getMethodValue()

{
    return this.httpRequest.getMethod();
}
org.springframework.http.client.HttpComponentsClientHttpRequest

@Override public URI getURI()

{
    return this.httpRequest.getURI();
}

HttpComponentsClientHttpRequestFactory
implements ClientHttpRequestFactory, DisposableBean

org.springframework.http.client.HttpComponentsClientHttpRequestFactory

public HttpComponentsClientHttpRequestFactory HttpComponentsClientHttpRequestFactory()

{
    this.httpClient = HttpClients.createSystem();
}
org.springframework.http.client.HttpComponentsClientHttpRequestFactory

public HttpComponentsClientHttpRequestFactory HttpComponentsClientHttpRequestFactory(HttpClient httpClient)

{
    this.httpClient = httpClient;
}
org.springframework.http.client.HttpComponentsClientHttpRequestFactory

@Nullable protected HttpContext createHttpContext(HttpMethod httpMethod, URI uri)

{
    return null;
}
org.springframework.http.client.HttpComponentsClientHttpRequestFactory

@Nullable protected RequestConfig createRequestConfig(Object client)

{
    if (client instanceof Configurable) {
        RequestConfig clientRequestConfig = ((Configurable)client).getConfig();
        return mergeRequestConfig(clientRequestConfig);
    } 
    return this.requestConfig;
}
org.springframework.http.client.HttpComponentsClientHttpRequestFactory

@Override public void destroy()

{
    HttpClient httpClient = getHttpClient();
    if (httpClient instanceof Closeable) {
        ((Closeable)httpClient).close();
    } 
}
org.springframework.http.client.HttpComponentsClientHttpRequestFactory

public HttpClient getHttpClient()

{
    return this.httpClient;
}
org.springframework.http.client.HttpComponentsClientHttpRequestFactory

protected RequestConfig mergeRequestConfig(RequestConfig clientConfig)

{
    if (this.requestConfig == null) {
        return clientConfig;
    } 
    RequestConfig.Builder builder = RequestConfig.copy(clientConfig);
    int connectTimeout = this.requestConfig.getConnectTimeout();
    if (connectTimeout >= 0) {
        builder.setConnectTimeout(connectTimeout);
    } 
    int connectionRequestTimeout = this.requestConfig.getConnectionRequestTimeout();
    if (connectionRequestTimeout >= 0) {
        builder.setConnectionRequestTimeout(connectionRequestTimeout);
    } 
    int socketTimeout = this.requestConfig.getSocketTimeout();
    if (socketTimeout >= 0) {
        builder.setSocketTimeout(socketTimeout);
    } 
    return builder.build();
}
org.springframework.http.client.HttpComponentsClientHttpRequestFactory

protected void postProcessHttpRequest(HttpUriRequest request)

{
}
org.springframework.http.client.HttpComponentsClientHttpRequestFactory

public void setBufferRequestBody(boolean bufferRequestBody)

{
    this.bufferRequestBody = bufferRequestBody;
}
org.springframework.http.client.HttpComponentsClientHttpRequestFactory

public void setConnectTimeout(int timeout)

{
    Assert.isTrue(timeout >= 0, "Timeout must be a non-negative value");
    this.requestConfig = requestConfigBuilder().setConnectTimeout(timeout).build();
}
org.springframework.http.client.HttpComponentsClientHttpRequestFactory

public void setConnectionRequestTimeout(int connectionRequestTimeout)

{
    this.requestConfig = requestConfigBuilder().setConnectionRequestTimeout(connectionRequestTimeout).build();
}
org.springframework.http.client.HttpComponentsClientHttpRequestFactory

public void setHttpClient(HttpClient httpClient)

{
    Assert.notNull(httpClient, "HttpClient must not be null");
    this.httpClient = httpClient;
}
org.springframework.http.client.HttpComponentsClientHttpRequestFactory

public void setReadTimeout(int timeout)

{
    Assert.isTrue(timeout >= 0, "Timeout must be a non-negative value");
    this.requestConfig = requestConfigBuilder().setSocketTimeout(timeout).build();
}

HttpComponentsClientHttpResponse
extends AbstractClientHttpResponse

org.springframework.http.client.HttpComponentsClientHttpResponse

@Override public void close()

{
    try {
        try {
            EntityUtils.consume(this.httpResponse.getEntity());
        } finally {
            if (this.httpResponse instanceof Closeable) {
                ((Closeable)this.httpResponse).close();
            } 
        }
    } catch (IOException ex) {
    }
}
org.springframework.http.client.HttpComponentsClientHttpResponse

@Override public InputStream getBody()

{
    HttpEntity entity = this.httpResponse.getEntity();
    return (entity != null ? entity.getContent() : StreamUtils.emptyInput());
}
org.springframework.http.client.HttpComponentsClientHttpResponse

@Override public HttpHeaders getHeaders()

{
    if (this.headers == null) {
        this.headers = new HttpHeaders();
        for (Header header: this.httpResponse.getAllHeaders()) {
            this.headers.add(header.getName(), header.getValue());
        }
    } 
    return this.headers;
}
org.springframework.http.client.HttpComponentsClientHttpResponse

@Override public int getRawStatusCode()

{
    return this.httpResponse.getStatusLine().getStatusCode();
}
org.springframework.http.client.HttpComponentsClientHttpResponse

@Override public String getStatusText()

{
    return this.httpResponse.getStatusLine().getReasonPhrase();
}

HttpComponentsStreamingClientHttpRequest
extends AbstractClientHttpRequest implements StreamingHttpOutputMessage

org.springframework.http.client.HttpComponentsStreamingClientHttpRequest

@Override protected ClientHttpResponse executeInternal(HttpHeaders headers)

{
    HttpComponentsClientHttpRequest.addHeaders(this.httpRequest, headers);
    if (this.httpRequest instanceof HttpEntityEnclosingRequest && this.body != null) {
        HttpEntityEnclosingRequest entityEnclosingRequest = (HttpEntityEnclosingRequest)this.httpRequest;
        HttpEntity requestEntity = new StreamingHttpEntity(getHeaders(), this.body);
        entityEnclosingRequest.setEntity(requestEntity);
    } 
    HttpResponse httpResponse = this.httpClient.execute(this.httpRequest, this.httpContext);
    return new HttpComponentsClientHttpResponse(httpResponse);
}
org.springframework.http.client.HttpComponentsStreamingClientHttpRequest

@Override protected OutputStream getBodyInternal(HttpHeaders headers)

{
    throw new UnsupportedOperationException("getBody not supported");
}
org.springframework.http.client.HttpComponentsStreamingClientHttpRequest

@Override public String getMethodValue()

{
    return this.httpRequest.getMethod();
}
org.springframework.http.client.HttpComponentsStreamingClientHttpRequest

@Override public URI getURI()

{
    return this.httpRequest.getURI();
}
org.springframework.http.client.HttpComponentsStreamingClientHttpRequest

@Override public void setBody(Body body)

{
    assertNotExecuted();
    this.body = body;
}

InterceptingAsyncClientHttpRequest
extends AbstractBufferingAsyncClientHttpRequest

org.springframework.http.client.InterceptingAsyncClientHttpRequest

public InterceptingAsyncClientHttpRequest InterceptingAsyncClientHttpRequest(AsyncClientHttpRequestFactory requestFactory, List<AsyncClientHttpRequestInterceptor> interceptors, URI uri, HttpMethod httpMethod)

{
    this.requestFactory = requestFactory;
    this.interceptors = interceptors;
    this.uri = uri;
    this.httpMethod = httpMethod;
}
org.springframework.http.client.InterceptingAsyncClientHttpRequest

@Override protected ListenableFuture<ClientHttpResponse> executeInternal(HttpHeaders headers, byte[] body)

{
    return new AsyncRequestExecution().executeAsync(this, body);
}
org.springframework.http.client.InterceptingAsyncClientHttpRequest

@Override public HttpMethod getMethod()

{
    return this.httpMethod;
}
org.springframework.http.client.InterceptingAsyncClientHttpRequest

@Override public String getMethodValue()

{
    return this.httpMethod.name();
}
org.springframework.http.client.InterceptingAsyncClientHttpRequest

@Override public URI getURI()

{
    return this.uri;
}

InterceptingAsyncClientHttpRequestFactory
implements AsyncClientHttpRequestFactory

org.springframework.http.client.InterceptingAsyncClientHttpRequestFactory

public InterceptingAsyncClientHttpRequestFactory InterceptingAsyncClientHttpRequestFactory(AsyncClientHttpRequestFactory delegate, @Nullable List<AsyncClientHttpRequestInterceptor> interceptors)

{
    this.delegate = delegate;
    this.interceptors = (interceptors != null ? interceptors : Collections.emptyList());
}
org.springframework.http.client.InterceptingAsyncClientHttpRequestFactory

@Override public AsyncClientHttpRequest createAsyncRequest(URI uri, HttpMethod method)

{
    return new InterceptingAsyncClientHttpRequest(this.delegate, this.interceptors, uri, method);
}

InterceptingClientHttpRequest
extends AbstractBufferingClientHttpRequest

org.springframework.http.client.InterceptingClientHttpRequest

protected InterceptingClientHttpRequest InterceptingClientHttpRequest(ClientHttpRequestFactory requestFactory, List<ClientHttpRequestInterceptor> interceptors, URI uri, HttpMethod method)

{
    this.requestFactory = requestFactory;
    this.interceptors = interceptors;
    this.method = method;
    this.uri = uri;
}
org.springframework.http.client.InterceptingClientHttpRequest

@Override protected final ClientHttpResponse executeInternal(HttpHeaders headers, byte[] bufferedOutput)

{
    InterceptingRequestExecution requestExecution = new InterceptingRequestExecution();
    return requestExecution.execute(this, bufferedOutput);
}
org.springframework.http.client.InterceptingClientHttpRequest

@Override public HttpMethod getMethod()

{
    return this.method;
}
org.springframework.http.client.InterceptingClientHttpRequest

@Override public String getMethodValue()

{
    return this.method.name();
}
org.springframework.http.client.InterceptingClientHttpRequest

@Override public URI getURI()

{
    return this.uri;
}

InterceptingClientHttpRequestFactory
extends AbstractClientHttpRequestFactoryWrapper

org.springframework.http.client.InterceptingClientHttpRequestFactory

public InterceptingClientHttpRequestFactory InterceptingClientHttpRequestFactory(ClientHttpRequestFactory requestFactory, @Nullable List<ClientHttpRequestInterceptor> interceptors)

{
    super(requestFactory);
    this.interceptors = (interceptors != null ? interceptors : Collections.emptyList());
}
org.springframework.http.client.InterceptingClientHttpRequestFactory

@Override protected ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod, ClientHttpRequestFactory requestFactory)

{
    return new InterceptingClientHttpRequest(requestFactory, this.interceptors, uri, httpMethod);
}

MultipartBodyBuilder

org.springframework.http.client.MultipartBodyBuilder

public MultipartBodyBuilder MultipartBodyBuilder()

{
}
PartBuilder
org.springframework.http.client.MultipartBodyBuilder

public PartBuilder part(String name, Object part)

{
    return part(name, part, null);
}

Netty4ClientHttpRequest
extends AbstractAsyncClientHttpRequest implements ClientHttpRequest

org.springframework.http.client.Netty4ClientHttpRequest

public Netty4ClientHttpRequest Netty4ClientHttpRequest(Bootstrap bootstrap, URI uri, HttpMethod method)

{
    this.bootstrap = bootstrap;
    this.uri = uri;
    this.method = method;
    this.body = new ByteBufOutputStream(Unpooled.buffer(1024));
}
org.springframework.http.client.Netty4ClientHttpRequest

@Override protected OutputStream getBodyInternal(HttpHeaders headers)

{
    return this.body;
}
org.springframework.http.client.Netty4ClientHttpRequest

@Override public HttpMethod getMethod()

{
    return this.method;
}
org.springframework.http.client.Netty4ClientHttpRequest

@Override public String getMethodValue()

{
    return this.method.name();
}
org.springframework.http.client.Netty4ClientHttpRequest

@Override public URI getURI()

{
    return this.uri;
}

Netty4ClientHttpRequestFactory
implements ClientHttpRequestFactory, AsyncClientHttpRequestFactory, InitializingBean, DisposableBean

org.springframework.http.client.Netty4ClientHttpRequestFactory

public static final int DEFAULT_MAX_RESPONSE_SIZE

org.springframework.http.client.Netty4ClientHttpRequestFactory

public Netty4ClientHttpRequestFactory Netty4ClientHttpRequestFactory()

{
    int ioWorkerCount = Runtime.getRuntime().availableProcessors() * 2;
    this.eventLoopGroup = new NioEventLoopGroup(ioWorkerCount);
    this.defaultEventLoopGroup = true;
}
org.springframework.http.client.Netty4ClientHttpRequestFactory

public Netty4ClientHttpRequestFactory Netty4ClientHttpRequestFactory(EventLoopGroup eventLoopGroup)

{
    Assert.notNull(eventLoopGroup, "EventLoopGroup must not be null");
    this.eventLoopGroup = eventLoopGroup;
    this.defaultEventLoopGroup = false;
}
org.springframework.http.client.Netty4ClientHttpRequestFactory

@Override public void afterPropertiesSet()

{
    if (this.sslContext == null) {
        this.sslContext = getDefaultClientSslContext();
    } 
}
org.springframework.http.client.Netty4ClientHttpRequestFactory

@Nullable volatile Bootstrap bootstrap

org.springframework.http.client.Netty4ClientHttpRequestFactory

protected void configureChannel(SocketChannelConfig config)

{
    if (this.connectTimeout >= 0) {
        config.setConnectTimeoutMillis(this.connectTimeout);
    } 
}
org.springframework.http.client.Netty4ClientHttpRequestFactory

@Override public AsyncClientHttpRequest createAsyncRequest(URI uri, HttpMethod httpMethod)

{
    return createRequestInternal(uri, httpMethod);
}
org.springframework.http.client.Netty4ClientHttpRequestFactory

@Override public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod)

{
    return createRequestInternal(uri, httpMethod);
}
org.springframework.http.client.Netty4ClientHttpRequestFactory

@Override public void destroy()

{
    if (this.defaultEventLoopGroup) {
        this.eventLoopGroup.shutdownGracefully().sync();
    } 
}
org.springframework.http.client.Netty4ClientHttpRequestFactory

public void setConnectTimeout(int connectTimeout)

{
    this.connectTimeout = connectTimeout;
}
org.springframework.http.client.Netty4ClientHttpRequestFactory

public void setMaxResponseSize(int maxResponseSize)

{
    this.maxResponseSize = maxResponseSize;
}
org.springframework.http.client.Netty4ClientHttpRequestFactory

public void setReadTimeout(int readTimeout)

{
    this.readTimeout = readTimeout;
}
org.springframework.http.client.Netty4ClientHttpRequestFactory

public void setSslContext(SslContext sslContext)

{
    this.sslContext = sslContext;
}

Netty4ClientHttpResponse
extends AbstractClientHttpResponse

org.springframework.http.client.Netty4ClientHttpResponse

@Override public void close()

{
    this.nettyResponse.release();
    this.context.close();
}
org.springframework.http.client.Netty4ClientHttpResponse

@Override public InputStream getBody()

{
    return this.body;
}
org.springframework.http.client.Netty4ClientHttpResponse

@Override public HttpHeaders getHeaders()

{
    HttpHeaders headers = this.headers;
    if (headers == null) {
        headers = new HttpHeaders();
        for (Map.Entry<String, String> entry: this.nettyResponse.headers()) {
            headers.add(entry.getKey(), entry.getValue());
        }
        this.headers = headers;
    } 
    return headers;
}
org.springframework.http.client.Netty4ClientHttpResponse

@Override public int getRawStatusCode()

{
    return this.nettyResponse.getStatus().code();
}
org.springframework.http.client.Netty4ClientHttpResponse

@Override public String getStatusText()

{
    return this.nettyResponse.getStatus().reasonPhrase();
}
org.springframework.http.client.Netty4ClientHttpResponse

@Nullable volatile HttpHeaders headers


OkHttp3AsyncClientHttpRequest
extends AbstractBufferingAsyncClientHttpRequest

org.springframework.http.client.OkHttp3AsyncClientHttpRequest

public OkHttp3AsyncClientHttpRequest OkHttp3AsyncClientHttpRequest(OkHttpClient client, URI uri, HttpMethod method)

{
    this.client = client;
    this.uri = uri;
    this.method = method;
}
org.springframework.http.client.OkHttp3AsyncClientHttpRequest

@Override protected ListenableFuture<ClientHttpResponse> executeInternal(HttpHeaders headers, byte[] content)

{
    Request request = OkHttp3ClientHttpRequestFactory.buildRequest(headers, content, this.uri, this.method);
    return new OkHttpListenableFuture(this.client.newCall(request));
}
org.springframework.http.client.OkHttp3AsyncClientHttpRequest

@Override public HttpMethod getMethod()

{
    return this.method;
}
org.springframework.http.client.OkHttp3AsyncClientHttpRequest

@Override public String getMethodValue()

{
    return this.method.name();
}
org.springframework.http.client.OkHttp3AsyncClientHttpRequest

@Override public URI getURI()

{
    return this.uri;
}

OkHttp3ClientHttpRequest
extends AbstractBufferingClientHttpRequest

org.springframework.http.client.OkHttp3ClientHttpRequest

public OkHttp3ClientHttpRequest OkHttp3ClientHttpRequest(OkHttpClient client, URI uri, HttpMethod method)

{
    this.client = client;
    this.uri = uri;
    this.method = method;
}
org.springframework.http.client.OkHttp3ClientHttpRequest

@Override protected ClientHttpResponse executeInternal(HttpHeaders headers, byte[] content)

{
    Request request = OkHttp3ClientHttpRequestFactory.buildRequest(headers, content, this.uri, this.method);
    return new OkHttp3ClientHttpResponse(this.client.newCall(request).execute());
}
org.springframework.http.client.OkHttp3ClientHttpRequest

@Override public HttpMethod getMethod()

{
    return this.method;
}
org.springframework.http.client.OkHttp3ClientHttpRequest

@Override public String getMethodValue()

{
    return this.method.name();
}
org.springframework.http.client.OkHttp3ClientHttpRequest

@Override public URI getURI()

{
    return this.uri;
}

OkHttp3ClientHttpRequestFactory
implements ClientHttpRequestFactory, AsyncClientHttpRequestFactory, DisposableBean

org.springframework.http.client.OkHttp3ClientHttpRequestFactory

public OkHttp3ClientHttpRequestFactory OkHttp3ClientHttpRequestFactory()

{
    this.client = new OkHttpClient();
    this.defaultClient = true;
}
org.springframework.http.client.OkHttp3ClientHttpRequestFactory

public OkHttp3ClientHttpRequestFactory OkHttp3ClientHttpRequestFactory(OkHttpClient client)

{
    Assert.notNull(client, "OkHttpClient must not be null");
    this.client = client;
    this.defaultClient = false;
}
org.springframework.http.client.OkHttp3ClientHttpRequestFactory

@Override public AsyncClientHttpRequest createAsyncRequest(URI uri, HttpMethod httpMethod)

{
    return new OkHttp3AsyncClientHttpRequest(this.client, uri, httpMethod);
}
org.springframework.http.client.OkHttp3ClientHttpRequestFactory

@Override public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod)

{
    return new OkHttp3ClientHttpRequest(this.client, uri, httpMethod);
}
org.springframework.http.client.OkHttp3ClientHttpRequestFactory

@Override public void destroy()

{
    if (this.defaultClient) {
        Cache cache = this.client.cache();
        if (cache != null) {
            cache.close();
        } 
        this.client.dispatcher().executorService().shutdown();
    } 
}
org.springframework.http.client.OkHttp3ClientHttpRequestFactory

public void setConnectTimeout(int connectTimeout)

{
    this.client = this.client.newBuilder().connectTimeout(connectTimeout, TimeUnit.MILLISECONDS).build();
}
org.springframework.http.client.OkHttp3ClientHttpRequestFactory

public void setReadTimeout(int readTimeout)

{
    this.client = this.client.newBuilder().readTimeout(readTimeout, TimeUnit.MILLISECONDS).build();
}
org.springframework.http.client.OkHttp3ClientHttpRequestFactory

public void setWriteTimeout(int writeTimeout)

{
    this.client = this.client.newBuilder().writeTimeout(writeTimeout, TimeUnit.MILLISECONDS).build();
}

OkHttp3ClientHttpResponse
extends AbstractClientHttpResponse

org.springframework.http.client.OkHttp3ClientHttpResponse

public OkHttp3ClientHttpResponse OkHttp3ClientHttpResponse(Response response)

{
    Assert.notNull(response, "Response must not be null");
    this.response = response;
}
org.springframework.http.client.OkHttp3ClientHttpResponse

@Override public void close()

{
    ResponseBody body = this.response.body();
    if (body != null) {
        body.close();
    } 
}
org.springframework.http.client.OkHttp3ClientHttpResponse

@Override public InputStream getBody()

{
    ResponseBody body = this.response.body();
    return (body != null ? body.byteStream() : StreamUtils.emptyInput());
}
org.springframework.http.client.OkHttp3ClientHttpResponse

@Override public int getRawStatusCode()

{
    return this.response.code();
}
org.springframework.http.client.OkHttp3ClientHttpResponse

@Override public String getStatusText()

{
    return this.response.message();
}
org.springframework.http.client.OkHttp3ClientHttpResponse

@Nullable volatile HttpHeaders headers


SimpleBufferingAsyncClientHttpRequest
extends AbstractBufferingAsyncClientHttpRequest

org.springframework.http.client.SimpleBufferingAsyncClientHttpRequest

@Override protected ListenableFuture<ClientHttpResponse> executeInternal(final HttpHeaders headers, final byte[] bufferedOutput)

{
    return this.taskExecutor.submitListenable(new Callable<ClientHttpResponse>() {
        @Override
        public ClientHttpResponse call() throws Exception{
            SimpleBufferingClientHttpRequest.addHeaders(connection, headers);
            if (getMethod() == HttpMethod.DELETE && bufferedOutput.length == 0) {
                connection.setDoOutput(false);
            } 
            if (connection.getDoOutput() && outputStreaming) {
                connection.setFixedLengthStreamingMode(bufferedOutput.length);
            } 
            connection.connect();
            if (connection.getDoOutput()) {
                FileCopyUtils.copy(bufferedOutput, connection.getOutputStream());
            } else {
                connection.getResponseCode();
            }
            return new SimpleClientHttpResponse(connection);
        }
    });
}
org.springframework.http.client.SimpleBufferingAsyncClientHttpRequest

@Override public String getMethodValue()

{
    return this.connection.getRequestMethod();
}
org.springframework.http.client.SimpleBufferingAsyncClientHttpRequest

@Override public URI getURI()

{
    try {
        return this.connection.getURL().toURI();
    } catch (URISyntaxException ex) {
        throw new IllegalStateException("Could not get HttpURLConnection URI: " + ex.getMessage(), ex);
    }
}

SimpleBufferingClientHttpRequest
extends AbstractBufferingClientHttpRequest

org.springframework.http.client.SimpleBufferingClientHttpRequest

@Override protected ClientHttpResponse executeInternal(HttpHeaders headers, byte[] bufferedOutput)

{
    addHeaders(this.connection, headers);
    if (getMethod() == HttpMethod.DELETE && bufferedOutput.length == 0) {
        this.connection.setDoOutput(false);
    } 
    if (this.connection.getDoOutput() && this.outputStreaming) {
        this.connection.setFixedLengthStreamingMode(bufferedOutput.length);
    } 
    this.connection.connect();
    if (this.connection.getDoOutput()) {
        FileCopyUtils.copy(bufferedOutput, this.connection.getOutputStream());
    } else {
        this.connection.getResponseCode();
    }
    return new SimpleClientHttpResponse(this.connection);
}
org.springframework.http.client.SimpleBufferingClientHttpRequest

@Override public String getMethodValue()

{
    return this.connection.getRequestMethod();
}
org.springframework.http.client.SimpleBufferingClientHttpRequest

@Override public URI getURI()

{
    try {
        return this.connection.getURL().toURI();
    } catch (URISyntaxException ex) {
        throw new IllegalStateException("Could not get HttpURLConnection URI: " + ex.getMessage(), ex);
    }
}

SimpleClientHttpRequestFactory
implements ClientHttpRequestFactory, AsyncClientHttpRequestFactory

org.springframework.http.client.SimpleClientHttpRequestFactory

protected HttpURLConnection openConnection(URL url, @Nullable Proxy proxy)

{
    URLConnection urlConnection = (proxy != null ? url.openConnection(proxy) : url.openConnection());
    if (!HttpURLConnection.class.isInstance(urlConnection)) {
        throw new IllegalStateException("HttpURLConnection required for [" + url + "] but got: " + urlConnection);
    } 
    return (HttpURLConnection)urlConnection;
}
org.springframework.http.client.SimpleClientHttpRequestFactory

protected void prepareConnection(HttpURLConnection connection, String httpMethod)

{
    if (this.connectTimeout >= 0) {
        connection.setConnectTimeout(this.connectTimeout);
    } 
    if (this.readTimeout >= 0) {
        connection.setReadTimeout(this.readTimeout);
    } 
    connection.setDoInput(true);
    if ("GET".equals(httpMethod)) {
        connection.setInstanceFollowRedirects(true);
    } else {
        connection.setInstanceFollowRedirects(false);
    }
    if ("POST".equals(httpMethod) || "PUT".equals(httpMethod) || "PATCH".equals(httpMethod) || "DELETE".equals(httpMethod)) {
        connection.setDoOutput(true);
    } else {
        connection.setDoOutput(false);
    }
    connection.setRequestMethod(httpMethod);
}
org.springframework.http.client.SimpleClientHttpRequestFactory

public void setBufferRequestBody(boolean bufferRequestBody)

{
    this.bufferRequestBody = bufferRequestBody;
}
org.springframework.http.client.SimpleClientHttpRequestFactory

public void setChunkSize(int chunkSize)

{
    this.chunkSize = chunkSize;
}
org.springframework.http.client.SimpleClientHttpRequestFactory

public void setConnectTimeout(int connectTimeout)

{
    this.connectTimeout = connectTimeout;
}
org.springframework.http.client.SimpleClientHttpRequestFactory

public void setOutputStreaming(boolean outputStreaming)

{
    this.outputStreaming = outputStreaming;
}
org.springframework.http.client.SimpleClientHttpRequestFactory

public void setProxy(Proxy proxy)

{
    this.proxy = proxy;
}
org.springframework.http.client.SimpleClientHttpRequestFactory

public void setReadTimeout(int readTimeout)

{
    this.readTimeout = readTimeout;
}
org.springframework.http.client.SimpleClientHttpRequestFactory

public void setTaskExecutor(AsyncListenableTaskExecutor taskExecutor)

{
    this.taskExecutor = taskExecutor;
}

SimpleClientHttpResponse
extends AbstractClientHttpResponse

org.springframework.http.client.SimpleClientHttpResponse

@Override public void close()

{
    try {
        if (this.responseStream == null) {
            getBody();
        } 
        StreamUtils.drain(this.responseStream);
        this.responseStream.close();
    } catch (Exception ex) {
    }
}
org.springframework.http.client.SimpleClientHttpResponse

@Override public HttpHeaders getHeaders()

{
    if (this.headers == null) {
        this.headers = new HttpHeaders();
        String name = this.connection.getHeaderFieldKey(0);
        if (StringUtils.hasLength(name)) {
            this.headers.add(name, this.connection.getHeaderField(0));
        } 
        int i = 1;
        while (true) {
            name = this.connection.getHeaderFieldKey(i);
            if (!StringUtils.hasLength(name)) {
                break;
            } 
            this.headers.add(name, this.connection.getHeaderField(i));
            i++;
        }
    } 
    return this.headers;
}
org.springframework.http.client.SimpleClientHttpResponse

@Override public int getRawStatusCode()

{
    return this.connection.getResponseCode();
}
org.springframework.http.client.SimpleClientHttpResponse

@Override public String getStatusText()

{
    String result = this.connection.getResponseMessage();
    return (result != null) ? result : "";
}

SimpleStreamingAsyncClientHttpRequest
extends AbstractAsyncClientHttpRequest

org.springframework.http.client.SimpleStreamingAsyncClientHttpRequest

@Override protected ListenableFuture<ClientHttpResponse> executeInternal(final HttpHeaders headers)

{
    return this.taskExecutor.submitListenable(new Callable<ClientHttpResponse>() {
        @Override
        public ClientHttpResponse call() throws Exception{
            try {
                if (body != null) {
                    body.close();
                } else {
                    SimpleBufferingClientHttpRequest.addHeaders(connection, headers);
                    connection.connect();
                    connection.getResponseCode();
                }
            } catch (IOException ex) {
            }
            return new SimpleClientHttpResponse(connection);
        }
    });
}
org.springframework.http.client.SimpleStreamingAsyncClientHttpRequest

@Override protected OutputStream getBodyInternal(HttpHeaders headers)

{
    if (this.body == null) {
        if (this.outputStreaming) {
            long contentLength = headers.getContentLength();
            if (contentLength >= 0) {
                this.connection.setFixedLengthStreamingMode(contentLength);
            } else {
                this.connection.setChunkedStreamingMode(this.chunkSize);
            }
        } 
        SimpleBufferingClientHttpRequest.addHeaders(this.connection, headers);
        this.connection.connect();
        this.body = this.connection.getOutputStream();
    } 
    return StreamUtils.nonClosing(this.body);
}
org.springframework.http.client.SimpleStreamingAsyncClientHttpRequest

@Override public String getMethodValue()

{
    return this.connection.getRequestMethod();
}
org.springframework.http.client.SimpleStreamingAsyncClientHttpRequest

@Override public URI getURI()

{
    try {
        return this.connection.getURL().toURI();
    } catch (URISyntaxException ex) {
        throw new IllegalStateException("Could not get HttpURLConnection URI: " + ex.getMessage(), ex);
    }
}

SimpleStreamingClientHttpRequest
extends AbstractClientHttpRequest

org.springframework.http.client.SimpleStreamingClientHttpRequest

@Override protected ClientHttpResponse executeInternal(HttpHeaders headers)

{
    try {
        if (this.body != null) {
            this.body.close();
        } else {
            SimpleBufferingClientHttpRequest.addHeaders(this.connection, headers);
            this.connection.connect();
            this.connection.getResponseCode();
        }
    } catch (IOException ex) {
    }
    return new SimpleClientHttpResponse(this.connection);
}
org.springframework.http.client.SimpleStreamingClientHttpRequest

@Override protected OutputStream getBodyInternal(HttpHeaders headers)

{
    if (this.body == null) {
        if (this.outputStreaming) {
            long contentLength = headers.getContentLength();
            if (contentLength >= 0) {
                this.connection.setFixedLengthStreamingMode(contentLength);
            } else {
                this.connection.setChunkedStreamingMode(this.chunkSize);
            }
        } 
        SimpleBufferingClientHttpRequest.addHeaders(this.connection, headers);
        this.connection.connect();
        this.body = this.connection.getOutputStream();
    } 
    return StreamUtils.nonClosing(this.body);
}
org.springframework.http.client.SimpleStreamingClientHttpRequest

@Override public String getMethodValue()

{
    return this.connection.getRequestMethod();
}
org.springframework.http.client.SimpleStreamingClientHttpRequest

@Override public URI getURI()

{
    try {
        return this.connection.getURL().toURI();
    } catch (URISyntaxException ex) {
        throw new IllegalStateException("Could not get HttpURLConnection URI: " + ex.getMessage(), ex);
    }
}


AbstractClientHttpRequest
implements ClientHttpRequest

org.springframework.http.client.reactive.AbstractClientHttpRequest

public AbstractClientHttpRequest AbstractClientHttpRequest()

{
    this(new HttpHeaders());
}
org.springframework.http.client.reactive.AbstractClientHttpRequest

public AbstractClientHttpRequest AbstractClientHttpRequest(HttpHeaders headers)

{
    Assert.notNull(headers, "HttpHeaders must not be null");
    this.headers = headers;
    this.cookies = new LinkedMultiValueMap<>();
}
org.springframework.http.client.reactive.AbstractClientHttpRequest

protected abstract void applyCookies()

org.springframework.http.client.reactive.AbstractClientHttpRequest

protected abstract void applyHeaders()

org.springframework.http.client.reactive.AbstractClientHttpRequest

@Override public void beforeCommit(Supplier<?> action)

{
    Assert.notNull(action, "Action must not be null");
    this.commitActions.add(action);
}
org.springframework.http.client.reactive.AbstractClientHttpRequest

protected Mono<Void> doCommit()

{
    return doCommit(null);
}
org.springframework.http.client.reactive.AbstractClientHttpRequest

protected Mono<Void> doCommit(@Nullable Supplier<?> writeAction)

{
    if (!this.state.compareAndSet(State.NEW, State.COMMITTING)) {
        return Mono.empty();
    } 
    this.commitActions.add(() -> Mono.fromRunnable(() -> {
        applyHeaders();
        applyCookies();
        this.state.set(State.COMMITTED);
    }));
    if (writeAction != null) {
        this.commitActions.add(writeAction);
    } 
    List<? extends Publisher<Void>> actions = this.commitActions.stream().map(Supplier::get).collect(Collectors.toList());
    return Flux.concat(actions).then();
}
org.springframework.http.client.reactive.AbstractClientHttpRequest

@Override public MultiValueMap<String, HttpCookie> getCookies()

{
    if (State.COMMITTED.equals(this.state.get())) {
        return CollectionUtils.unmodifiableMultiValueMap(this.cookies);
    } 
    return this.cookies;
}
org.springframework.http.client.reactive.AbstractClientHttpRequest

@Override public HttpHeaders getHeaders()

{
    if (State.COMMITTED.equals(this.state.get())) {
        return HttpHeaders.readOnlyHttpHeaders(this.headers);
    } 
    return this.headers;
}
org.springframework.http.client.reactive.AbstractClientHttpRequest

@Override public boolean isCommitted()

{
    return (this.state.get() != State.NEW);
}

ClientHttpConnector

ClientHttpRequest
inherit classes
  • ReactiveHttpOutputMessage

ClientHttpRequestDecorator
implements ClientHttpRequest

org.springframework.http.client.reactive.ClientHttpRequestDecorator

public ClientHttpRequestDecorator ClientHttpRequestDecorator(ClientHttpRequest delegate)

{
    Assert.notNull(delegate, "Delegate is required");
    this.delegate = delegate;
}
org.springframework.http.client.reactive.ClientHttpRequestDecorator

@Override public void beforeCommit(Supplier<?> action)

{
    this.delegate.beforeCommit(action);
}
org.springframework.http.client.reactive.ClientHttpRequestDecorator

@Override public DataBufferFactory bufferFactory()

{
    return this.delegate.bufferFactory();
}
org.springframework.http.client.reactive.ClientHttpRequestDecorator

@Override public MultiValueMap<String, HttpCookie> getCookies()

{
    return this.delegate.getCookies();
}
org.springframework.http.client.reactive.ClientHttpRequestDecorator

public ClientHttpRequest getDelegate()

{
    return this.delegate;
}
org.springframework.http.client.reactive.ClientHttpRequestDecorator

@Override public HttpHeaders getHeaders()

{
    return this.delegate.getHeaders();
}
org.springframework.http.client.reactive.ClientHttpRequestDecorator

@Override public HttpMethod getMethod()

{
    return this.delegate.getMethod();
}
org.springframework.http.client.reactive.ClientHttpRequestDecorator

@Override public URI getURI()

{
    return this.delegate.getURI();
}
org.springframework.http.client.reactive.ClientHttpRequestDecorator

@Override public boolean isCommitted()

{
    return this.delegate.isCommitted();
}
org.springframework.http.client.reactive.ClientHttpRequestDecorator

@Override public Mono<Void> setComplete()

{
    return this.delegate.setComplete();
}
org.springframework.http.client.reactive.ClientHttpRequestDecorator

@Override public String toString()

{
    return getClass().getSimpleName() + " [delegate=" + getDelegate() + "]";
}
org.springframework.http.client.reactive.ClientHttpRequestDecorator

@Override public Mono<Void> writeAndFlushWith(Publisher<?> body)

{
    return this.delegate.writeAndFlushWith(body);
}
org.springframework.http.client.reactive.ClientHttpRequestDecorator

@Override public Mono<Void> writeWith(Publisher<?> body)

{
    return this.delegate.writeWith(body);
}

ClientHttpResponse
inherit classes
  • ReactiveHttpInputMessage

ClientHttpResponseDecorator
implements ClientHttpResponse

org.springframework.http.client.reactive.ClientHttpResponseDecorator

public ClientHttpResponseDecorator ClientHttpResponseDecorator(ClientHttpResponse delegate)

{
    Assert.notNull(delegate, "Delegate is required");
    this.delegate = delegate;
}
org.springframework.http.client.reactive.ClientHttpResponseDecorator

@Override public Flux<DataBuffer> getBody()

{
    return this.delegate.getBody();
}
org.springframework.http.client.reactive.ClientHttpResponseDecorator

@Override public MultiValueMap<String, ResponseCookie> getCookies()

{
    return this.delegate.getCookies();
}
org.springframework.http.client.reactive.ClientHttpResponseDecorator

public ClientHttpResponse getDelegate()

{
    return this.delegate;
}
org.springframework.http.client.reactive.ClientHttpResponseDecorator

@Override public HttpHeaders getHeaders()

{
    return this.delegate.getHeaders();
}
org.springframework.http.client.reactive.ClientHttpResponseDecorator

@Override public int getRawStatusCode()

{
    return this.delegate.getRawStatusCode();
}
org.springframework.http.client.reactive.ClientHttpResponseDecorator

@Override public HttpStatus getStatusCode()

{
    return this.delegate.getStatusCode();
}
org.springframework.http.client.reactive.ClientHttpResponseDecorator

@Override public String toString()

{
    return getClass().getSimpleName() + " [delegate=" + getDelegate() + "]";
}

JettyClientHttpConnector
implements ClientHttpConnector

org.springframework.http.client.reactive.JettyClientHttpConnector

public JettyClientHttpConnector JettyClientHttpConnector()

{
    this(new HttpClient());
}
org.springframework.http.client.reactive.JettyClientHttpConnector

public JettyClientHttpConnector JettyClientHttpConnector(HttpClient httpClient)

{
    this(httpClient, null);
}
org.springframework.http.client.reactive.JettyClientHttpConnector

public JettyClientHttpConnector JettyClientHttpConnector(HttpClient httpClient, @Nullable JettyResourceFactory resourceFactory)

{
    Assert.notNull(httpClient, "HttpClient is required");
    if (resourceFactory != null) {
        httpClient.setExecutor(resourceFactory.getExecutor());
        httpClient.setByteBufferPool(resourceFactory.getByteBufferPool());
        httpClient.setScheduler(resourceFactory.getScheduler());
    } 
    this.httpClient = httpClient;
}
org.springframework.http.client.reactive.JettyClientHttpConnector

@Deprecated public JettyClientHttpConnector JettyClientHttpConnector(JettyResourceFactory resourceFactory, @Nullable Consumer<HttpClient> customizer)

{
    this(new HttpClient(), resourceFactory);
    if (customizer != null) {
        customizer.accept(this.httpClient);
    } 
}
org.springframework.http.client.reactive.JettyClientHttpConnector

@Override public Mono<ClientHttpResponse> connect(HttpMethod method, URI uri, Function<?, Mono<Void>> requestCallback)

{
    if (!uri.isAbsolute()) {
        return Mono.error(new IllegalArgumentException("URI is not absolute: " + uri));
    } 
    if (!this.httpClient.isStarted()) {
        try {
            this.httpClient.start();
        } catch (Exception ex) {
            return Mono.error(ex);
        }
    } 
    JettyClientHttpRequest clientHttpRequest = new JettyClientHttpRequest(this.httpClient.newRequest(uri).method(method.toString()), this.bufferFactory);
    return requestCallback.apply(clientHttpRequest).then(Mono.from(clientHttpRequest.getReactiveRequest().response((response, chunks) -> {
        Flux<DataBuffer> content = Flux.from(chunks).map(this::toDataBuffer);
        return Mono.just(new JettyClientHttpResponse(response, content));
    })));
}
org.springframework.http.client.reactive.JettyClientHttpConnector

public void setBufferFactory(DataBufferFactory bufferFactory)

{
    this.bufferFactory = bufferFactory;
}

JettyClientHttpRequest
extends AbstractClientHttpRequest

org.springframework.http.client.reactive.JettyClientHttpRequest

public JettyClientHttpRequest JettyClientHttpRequest(Request jettyRequest, DataBufferFactory bufferFactory)

{
    this.jettyRequest = jettyRequest;
    this.bufferFactory = bufferFactory;
}
org.springframework.http.client.reactive.JettyClientHttpRequest

@Override public DataBufferFactory bufferFactory()

{
    return this.bufferFactory;
}
org.springframework.http.client.reactive.JettyClientHttpRequest

@Override public HttpMethod getMethod()

{
    HttpMethod method = HttpMethod.resolve(this.jettyRequest.getMethod());
    Assert.state(method != null, "Method must not be null");
    return method;
}
org.springframework.http.client.reactive.JettyClientHttpRequest

@Override public URI getURI()

{
    return this.jettyRequest.getURI();
}
org.springframework.http.client.reactive.JettyClientHttpRequest

@Override public Mono<Void> setComplete()

{
    return doCommit(this::completes);
}

JettyClientHttpResponse
implements ClientHttpResponse

org.springframework.http.client.reactive.JettyClientHttpResponse

public JettyClientHttpResponse JettyClientHttpResponse(ReactiveResponse reactiveResponse, Publisher<DataBuffer> content)

{
    this.reactiveResponse = reactiveResponse;
    this.content = Flux.from(content);
}
org.springframework.http.client.reactive.JettyClientHttpResponse

@Override public Flux<DataBuffer> getBody()

{
    return this.content;
}
org.springframework.http.client.reactive.JettyClientHttpResponse

@Override public int getRawStatusCode()

{
    return this.reactiveResponse.getStatus();
}
org.springframework.http.client.reactive.JettyClientHttpResponse

@Override public HttpStatus getStatusCode()

{
    return HttpStatus.valueOf(getRawStatusCode());
}

JettyResourceFactory
implements InitializingBean, DisposableBean

org.springframework.http.client.reactive.JettyResourceFactory

@Override public void destroy()

{
    try {
        if (this.executor instanceof LifeCycle) {
            ((LifeCycle)this.executor).stop();
        } 
    } catch (Throwable ex) {
    }
    try {
        if (this.scheduler != null) {
            this.scheduler.stop();
        } 
    } catch (Throwable ex) {
    }
}
org.springframework.http.client.reactive.JettyResourceFactory

@Nullable public ByteBufferPool getByteBufferPool()

{
    return this.byteBufferPool;
}
org.springframework.http.client.reactive.JettyResourceFactory

@Nullable public Executor getExecutor()

{
    return this.executor;
}
org.springframework.http.client.reactive.JettyResourceFactory

@Nullable public Scheduler getScheduler()

{
    return this.scheduler;
}
org.springframework.http.client.reactive.JettyResourceFactory

public void setByteBufferPool(@Nullable ByteBufferPool byteBufferPool)

{
    this.byteBufferPool = byteBufferPool;
}
org.springframework.http.client.reactive.JettyResourceFactory

public void setExecutor(@Nullable Executor executor)

{
    this.executor = executor;
}
org.springframework.http.client.reactive.JettyResourceFactory

public void setScheduler(@Nullable Scheduler scheduler)

{
    this.scheduler = scheduler;
}
org.springframework.http.client.reactive.JettyResourceFactory

public void setThreadPrefix(String threadPrefix)

{
    Assert.notNull(threadPrefix, "Thread prefix is required");
    this.threadPrefix = threadPrefix;
}

ReactorClientHttpConnector
implements ClientHttpConnector

org.springframework.http.client.reactive.ReactorClientHttpConnector

public ReactorClientHttpConnector ReactorClientHttpConnector()

{
    this.httpClient = defaultInitializer.apply(HttpClient.create());
}
org.springframework.http.client.reactive.ReactorClientHttpConnector

public ReactorClientHttpConnector ReactorClientHttpConnector(ReactorResourceFactory factory, Function<HttpClient, HttpClient> mapper)

{
    this.httpClient = defaultInitializer.andThen(mapper).apply(initHttpClient(factory));
}
org.springframework.http.client.reactive.ReactorClientHttpConnector

public ReactorClientHttpConnector ReactorClientHttpConnector(HttpClient httpClient)

{
    Assert.notNull(httpClient, "HttpClient is required");
    this.httpClient = httpClient;
}
org.springframework.http.client.reactive.ReactorClientHttpConnector

@Override public Mono<ClientHttpResponse> connect(HttpMethod method, URI uri, Function<?, Mono<Void>> requestCallback)

{
    if (!uri.isAbsolute()) {
        return Mono.error(new IllegalArgumentException("URI is not absolute: " + uri));
    } 
    return this.httpClient.request(io.netty.handler.codec.http.HttpMethod.valueOf(method.name())).uri(uri.toString()).send((request, outbound) -> requestCallback.apply(adaptRequest(method, uri, request, outbound))).responseConnection((res, con) -> Mono.just(adaptResponse(res, con.inbound(), con.outbound().alloc()))).next();
}

ReactorClientHttpRequest
extends AbstractClientHttpRequest implements ZeroCopyHttpOutputMessage

org.springframework.http.client.reactive.ReactorClientHttpRequest

public ReactorClientHttpRequest ReactorClientHttpRequest(HttpMethod method, URI uri, HttpClientRequest request, NettyOutbound outbound)

{
    this.httpMethod = method;
    this.uri = uri;
    this.request = request;
    this.outbound = outbound;
    this.bufferFactory = new NettyDataBufferFactory(outbound.alloc());
}
org.springframework.http.client.reactive.ReactorClientHttpRequest

@Override protected void applyHeaders()

{
    getHeaders().forEach((key, value) -> this.request.requestHeaders().set(key, value));
}
org.springframework.http.client.reactive.ReactorClientHttpRequest

@Override public DataBufferFactory bufferFactory()

{
    return this.bufferFactory;
}
org.springframework.http.client.reactive.ReactorClientHttpRequest

@Override public HttpMethod getMethod()

{
    return this.httpMethod;
}
org.springframework.http.client.reactive.ReactorClientHttpRequest

@Override public URI getURI()

{
    return this.uri;
}
org.springframework.http.client.reactive.ReactorClientHttpRequest

@Override public Mono<Void> setComplete()

{
    return doCommit(this.outbound::then);
}
org.springframework.http.client.reactive.ReactorClientHttpRequest

@Override public Mono<Void> writeAndFlushWith(Publisher<?> body)

{
    Publisher<Publisher<ByteBuf>> byteBufs = Flux.from(body).map(ReactorClientHttpRequest::toByteBufs);
    return doCommit(() -> this.outbound.sendGroups(byteBufs).then());
}
org.springframework.http.client.reactive.ReactorClientHttpRequest

@Override public Mono<Void> writeWith(Path file, long position, long count)

{
    return doCommit(() -> this.outbound.sendFile(file, position, count).then());
}

ReactorClientHttpResponse
implements ClientHttpResponse

org.springframework.http.client.reactive.ReactorClientHttpResponse

public ReactorClientHttpResponse ReactorClientHttpResponse(HttpClientResponse response, NettyInbound inbound, ByteBufAllocator alloc)

{
    this.response = response;
    this.inbound = inbound;
    this.bufferFactory = new NettyDataBufferFactory(alloc);
}
org.springframework.http.client.reactive.ReactorClientHttpResponse

@Override public Flux<DataBuffer> getBody()

{
    return this.inbound.receive().doOnSubscribe(s -> {
        if (this.rejectSubscribers.get()) {
            throw new IllegalStateException("The client response body can only be consumed once.");
        } 
    }).doOnCancel(() -> this.rejectSubscribers.set(true)).map(byteBuf -> {
        byteBuf.retain();
        return this.bufferFactory.wrap(byteBuf);
    });
}
org.springframework.http.client.reactive.ReactorClientHttpResponse

@Override public HttpHeaders getHeaders()

{
    HttpHeaders headers = new HttpHeaders();
    this.response.responseHeaders().entries().forEach(e -> headers.add(e.getKey(), e.getValue()));
    return headers;
}
org.springframework.http.client.reactive.ReactorClientHttpResponse

@Override public int getRawStatusCode()

{
    return this.response.status().code();
}
org.springframework.http.client.reactive.ReactorClientHttpResponse

@Override public HttpStatus getStatusCode()

{
    return HttpStatus.valueOf(getRawStatusCode());
}

ReactorResourceFactory
implements InitializingBean, DisposableBean

org.springframework.http.client.reactive.ReactorResourceFactory

public void addGlobalResourcesConsumer(Consumer<HttpResources> consumer)

{
    this.useGlobalResources = true;
    this.globalResourcesConsumer = this.globalResourcesConsumer != null ? this.globalResourcesConsumer.andThen(consumer) : consumer;
}
org.springframework.http.client.reactive.ReactorResourceFactory

public ConnectionProvider getConnectionProvider()

{
    Assert.state(this.connectionProvider != null, "ConnectionProvider not initialized yet");
    return this.connectionProvider;
}
org.springframework.http.client.reactive.ReactorResourceFactory

public LoopResources getLoopResources()

{
    Assert.state(this.loopResources != null, "LoopResources not initialized yet");
    return this.loopResources;
}
org.springframework.http.client.reactive.ReactorResourceFactory

public boolean isUseGlobalResources()

{
    return this.useGlobalResources;
}
org.springframework.http.client.reactive.ReactorResourceFactory

public void setConnectionProvider(ConnectionProvider connectionProvider)

{
    this.connectionProvider = connectionProvider;
}
org.springframework.http.client.reactive.ReactorResourceFactory

public void setConnectionProviderSupplier(Supplier<ConnectionProvider> supplier)

{
    this.connectionProviderSupplier = supplier;
}
org.springframework.http.client.reactive.ReactorResourceFactory

public void setLoopResources(LoopResources loopResources)

{
    this.loopResources = loopResources;
}
org.springframework.http.client.reactive.ReactorResourceFactory

public void setLoopResourcesSupplier(Supplier<LoopResources> supplier)

{
    this.loopResourcesSupplier = supplier;
}
org.springframework.http.client.reactive.ReactorResourceFactory

public void setUseGlobalResources(boolean useGlobalResources)

{
    this.useGlobalResources = useGlobalResources;
}


AsyncHttpAccessor

org.springframework.http.client.support.AsyncHttpAccessor

protected org.springframework.http.client.AsyncClientHttpRequest createAsyncRequest(URI url, HttpMethod method)

{
    org.springframework.http.client.AsyncClientHttpRequest request = getAsyncRequestFactory().createAsyncRequest(url, method);
    if (logger.isDebugEnabled()) {
        logger.debug("Created asynchronous " + method.name() + " request for \"" + url + "\"");
    } 
    return request;
}
org.springframework.http.client.support.AsyncHttpAccessor

public org.springframework.http.client.AsyncClientHttpRequestFactory getAsyncRequestFactory()

{
    Assert.state(this.asyncRequestFactory != null, "No AsyncClientHttpRequestFactory set");
    return this.asyncRequestFactory;
}
org.springframework.http.client.support.AsyncHttpAccessor

protected final Log logger

org.springframework.http.client.support.AsyncHttpAccessor

public void setAsyncRequestFactory(org.springframework.http.client.AsyncClientHttpRequestFactory asyncRequestFactory)

{
    Assert.notNull(asyncRequestFactory, "AsyncClientHttpRequestFactory must not be null");
    this.asyncRequestFactory = asyncRequestFactory;
}

BasicAuthenticationInterceptor
implements ClientHttpRequestInterceptor

org.springframework.http.client.support.BasicAuthenticationInterceptor

public BasicAuthenticationInterceptor BasicAuthenticationInterceptor(String username, String password)

{
    this(username, password, null);
}
org.springframework.http.client.support.BasicAuthenticationInterceptor

public BasicAuthenticationInterceptor BasicAuthenticationInterceptor(String username, String password, @Nullable Charset charset)

{
    this.encodedCredentials = HttpHeaders.encodeBasicAuth(username, password, charset);
}
org.springframework.http.client.support.BasicAuthenticationInterceptor

@Override public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution)

{
    HttpHeaders headers = request.getHeaders();
    if (!headers.containsKey(HttpHeaders.AUTHORIZATION)) {
        headers.setBasicAuth(this.encodedCredentials);
    } 
    return execution.execute(request, body);
}

BasicAuthorizationInterceptor
implements ClientHttpRequestInterceptor

org.springframework.http.client.support.BasicAuthorizationInterceptor

public BasicAuthorizationInterceptor BasicAuthorizationInterceptor(@Nullable String username, @Nullable String password)

{
    Assert.doesNotContain(username, ":", "Username must not contain a colon");
    this.username = (username != null ? username : "");
    this.password = (password != null ? password : "");
}
org.springframework.http.client.support.BasicAuthorizationInterceptor

@Override public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution)

{
    String token = Base64Utils.encodeToString((this.username + ":" + this.password).getBytes(StandardCharsets.UTF_8));
    request.getHeaders().add("Authorization", "Basic " + token);
    return execution.execute(request, body);
}

HttpAccessor

org.springframework.http.client.support.HttpAccessor

protected ClientHttpRequest createRequest(URI url, HttpMethod method)

{
    ClientHttpRequest request = getRequestFactory().createRequest(url, method);
    initialize(request);
    if (logger.isDebugEnabled()) {
        logger.debug("HTTP " + method.name() + " " + url);
    } 
    return request;
}
org.springframework.http.client.support.HttpAccessor

public List<ClientHttpRequestInitializer> getClientHttpRequestInitializers()

{
    return this.clientHttpRequestInitializers;
}
org.springframework.http.client.support.HttpAccessor

public ClientHttpRequestFactory getRequestFactory()

{
    return this.requestFactory;
}
org.springframework.http.client.support.HttpAccessor

protected final Log logger

org.springframework.http.client.support.HttpAccessor

public void setRequestFactory(ClientHttpRequestFactory requestFactory)

{
    Assert.notNull(requestFactory, "ClientHttpRequestFactory must not be null");
    this.requestFactory = requestFactory;
}

HttpRequestWrapper
implements HttpRequest

org.springframework.http.client.support.HttpRequestWrapper

public HttpRequestWrapper HttpRequestWrapper(HttpRequest request)

{
    Assert.notNull(request, "HttpRequest must not be null");
    this.request = request;
}
org.springframework.http.client.support.HttpRequestWrapper

@Override public HttpHeaders getHeaders()

{
    return this.request.getHeaders();
}
org.springframework.http.client.support.HttpRequestWrapper

@Override @Nullable public HttpMethod getMethod()

{
    return this.request.getMethod();
}
org.springframework.http.client.support.HttpRequestWrapper

@Override public String getMethodValue()

{
    return this.request.getMethodValue();
}
org.springframework.http.client.support.HttpRequestWrapper

public HttpRequest getRequest()

{
    return this.request;
}
org.springframework.http.client.support.HttpRequestWrapper

@Override public URI getURI()

{
    return this.request.getURI();
}

InterceptingAsyncHttpAccessor
extends AsyncHttpAccessor

org.springframework.http.client.support.InterceptingAsyncHttpAccessor

public List<org.springframework.http.client.AsyncClientHttpRequestInterceptor> getInterceptors()

{
    return this.interceptors;
}
org.springframework.http.client.support.InterceptingAsyncHttpAccessor

public void setInterceptors(List<org.springframework.http.client.AsyncClientHttpRequestInterceptor> interceptors)

{
    this.interceptors = interceptors;
}

InterceptingHttpAccessor
extends HttpAccessor

org.springframework.http.client.support.InterceptingHttpAccessor

public List<ClientHttpRequestInterceptor> getInterceptors()

{
    return this.interceptors;
}
org.springframework.http.client.support.InterceptingHttpAccessor

@Nullable volatile ClientHttpRequestFactory interceptingRequestFactory

org.springframework.http.client.support.InterceptingHttpAccessor

public void setInterceptors(List<ClientHttpRequestInterceptor> interceptors)

{
    if (this.interceptors != interceptors) {
        this.interceptors.clear();
        this.interceptors.addAll(interceptors);
        AnnotationAwareOrderComparator.sort(this.interceptors);
    } 
}
org.springframework.http.client.support.InterceptingHttpAccessor

@Override public void setRequestFactory(ClientHttpRequestFactory requestFactory)

{
    super.setRequestFactory(requestFactory);
    this.interceptingRequestFactory = null;
}

ProxyFactoryBean
implements FactoryBean<Proxy>, InitializingBean

org.springframework.http.client.support.ProxyFactoryBean

@Override public void afterPropertiesSet()

{
    Assert.notNull(this.type, "Property 'type' is required");
    Assert.notNull(this.hostname, "Property 'hostname' is required");
    if (this.port < 0 || this.port > 65535) {
        throw new IllegalArgumentException("Property 'port' value out of range: " + this.port);
    } 
    SocketAddress socketAddress = new InetSocketAddress(this.hostname, this.port);
    this.proxy = new Proxy(this.type, socketAddress);
}
org.springframework.http.client.support.ProxyFactoryBean

@Override @Nullable public Proxy getObject()

{
    return this.proxy;
}
org.springframework.http.client.support.ProxyFactoryBean

@Override public Class<?> getObjectType()

{
    return Proxy.class;
}
org.springframework.http.client.support.ProxyFactoryBean

@Override public boolean isSingleton()

{
    return true;
}
org.springframework.http.client.support.ProxyFactoryBean

public void setHostname(String hostname)

{
    this.hostname = hostname;
}
org.springframework.http.client.support.ProxyFactoryBean

public void setPort(int port)

{
    this.port = port;
}
org.springframework.http.client.support.ProxyFactoryBean

public void setType(Proxy.Type type)

{
    this.type = type;
}


ClientCodecConfigurer
inherit classes
  • CodecConfigurer

CodecConfigurer

CodecConfigurerFactory

org.springframework.http.codec.CodecConfigurerFactory

<T>@SuppressWarnings("unchecked") public static T create(Class<T> ifc)

{
    Class<?> impl = defaultCodecConfigurers.get(ifc);
    if (impl == null) {
        throw new IllegalStateException("No default codec configurer found for " + ifc);
    } 
    return (T)BeanUtils.instantiateClass(impl);
}

DecoderHttpMessageReader<T>
implements HttpMessageReader<T>

org.springframework.http.codec.DecoderHttpMessageReader

public DecoderHttpMessageReader DecoderHttpMessageReader(Decoder<T> decoder)

{
    Assert.notNull(decoder, "Decoder is required");
    initLogger(decoder);
    this.decoder = decoder;
    this.mediaTypes = MediaType.asMediaTypes(decoder.getDecodableMimeTypes());
}
org.springframework.http.codec.DecoderHttpMessageReader

@Override public boolean canRead(ResolvableType elementType, @Nullable MediaType mediaType)

{
    return this.decoder.canDecode(elementType, mediaType);
}
org.springframework.http.codec.DecoderHttpMessageReader

@Nullable protected MediaType getContentType(HttpMessage inputMessage)

{
    MediaType contentType = inputMessage.getHeaders().getContentType();
    return (contentType != null ? contentType : MediaType.APPLICATION_OCTET_STREAM);
}
org.springframework.http.codec.DecoderHttpMessageReader

public Decoder<T> getDecoder()

{
    return this.decoder;
}
org.springframework.http.codec.DecoderHttpMessageReader

protected Map<String, Object> getReadHints(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response)

{
    if (this.decoder instanceof HttpMessageDecoder) {
        HttpMessageDecoder<?> decoder = (HttpMessageDecoder<?>)this.decoder;
        return decoder.getDecodeHints(actualType, elementType, request, response);
    } 
    return Hints.none();
}
org.springframework.http.codec.DecoderHttpMessageReader

@Override public List<MediaType> getReadableMediaTypes()

{
    return this.mediaTypes;
}
org.springframework.http.codec.DecoderHttpMessageReader

@Override public Flux<T> read(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String, Object> hints)

{
    MediaType contentType = getContentType(message);
    return this.decoder.decode(message.getBody(), elementType, contentType, hints);
}
org.springframework.http.codec.DecoderHttpMessageReader

@Override public Flux<T> read(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response, Map<String, Object> hints)

{
    Map<String, Object> allHints = Hints.merge(hints, getReadHints(actualType, elementType, request, response));
    return read(elementType, request, allHints);
}
org.springframework.http.codec.DecoderHttpMessageReader

@Override public Mono<T> readMono(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String, Object> hints)

{
    MediaType contentType = getContentType(message);
    return this.decoder.decodeToMono(message.getBody(), elementType, contentType, hints);
}
org.springframework.http.codec.DecoderHttpMessageReader

@Override public Mono<T> readMono(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response, Map<String, Object> hints)

{
    Map<String, Object> allHints = Hints.merge(hints, getReadHints(actualType, elementType, request, response));
    return readMono(elementType, request, allHints);
}

EncoderHttpMessageWriter<T>
implements HttpMessageWriter<T>

org.springframework.http.codec.EncoderHttpMessageWriter

@Override public boolean canWrite(ResolvableType elementType, @Nullable MediaType mediaType)

{
    return this.encoder.canEncode(elementType, mediaType);
}
org.springframework.http.codec.EncoderHttpMessageWriter

public Encoder<T> getEncoder()

{
    return this.encoder;
}
org.springframework.http.codec.EncoderHttpMessageWriter

@Override public List<MediaType> getWritableMediaTypes()

{
    return this.mediaTypes;
}
org.springframework.http.codec.EncoderHttpMessageWriter

protected Map<String, Object> getWriteHints(ResolvableType streamType, ResolvableType elementType, @Nullable MediaType mediaType, ServerHttpRequest request, ServerHttpResponse response)

{
    if (this.encoder instanceof HttpMessageEncoder) {
        HttpMessageEncoder<?> encoder = (HttpMessageEncoder<?>)this.encoder;
        return encoder.getEncodeHints(streamType, elementType, mediaType, request, response);
    } 
    return Hints.none();
}
org.springframework.http.codec.EncoderHttpMessageWriter

@Override public Mono<Void> write(Publisher<?> inputStream, ResolvableType actualType, ResolvableType elementType, @Nullable MediaType mediaType, ServerHttpRequest request, ServerHttpResponse response, Map<String, Object> hints)

{
    Map<String, Object> allHints = Hints.merge(hints, getWriteHints(actualType, elementType, mediaType, request, response));
    return write(inputStream, elementType, mediaType, response, allHints);
}

FormHttpMessageReader
extends LoggingCodecSupport implements HttpMessageReader<MultiValueMap<String, String>>

org.springframework.http.codec.FormHttpMessageReader

public static final Charset DEFAULT_CHARSET

org.springframework.http.codec.FormHttpMessageReader

public Charset getDefaultCharset()

{
    return this.defaultCharset;
}
org.springframework.http.codec.FormHttpMessageReader

@Override public List<MediaType> getReadableMediaTypes()

{
    return Collections.singletonList(MediaType.APPLICATION_FORM_URLENCODED);
}
org.springframework.http.codec.FormHttpMessageReader

@Override public Flux<MultiValueMap<String, String>> read(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String, Object> hints)

{
    return Flux.from(readMono(elementType, message, hints));
}
org.springframework.http.codec.FormHttpMessageReader

public void setDefaultCharset(Charset charset)

{
    Assert.notNull(charset, "Charset must not be null");
    this.defaultCharset = charset;
}

FormHttpMessageWriter
extends LoggingCodecSupport implements HttpMessageWriter<MultiValueMap<String, String>>

org.springframework.http.codec.FormHttpMessageWriter

public static final Charset DEFAULT_CHARSET

org.springframework.http.codec.FormHttpMessageWriter

@Override public boolean canWrite(ResolvableType elementType, @Nullable MediaType mediaType)

{
    if (!MultiValueMap.class.isAssignableFrom(elementType.toClass())) {
        return false;
    } 
    if (MediaType.APPLICATION_FORM_URLENCODED.isCompatibleWith(mediaType)) {
        return true;
    } 
    if (mediaType == null) {
        return MULTIVALUE_TYPE.isAssignableFrom(elementType);
    } 
    return false;
}
org.springframework.http.codec.FormHttpMessageWriter

public Charset getDefaultCharset()

{
    return this.defaultCharset;
}
org.springframework.http.codec.FormHttpMessageWriter

protected MediaType getMediaType(@Nullable MediaType mediaType)

{
    if (mediaType == null) {
        return DEFAULT_FORM_DATA_MEDIA_TYPE;
    } else if (mediaType.getCharset() == null) {
        return new MediaType(mediaType, getDefaultCharset());
    } else {
        return mediaType;
    }
}
org.springframework.http.codec.FormHttpMessageWriter

@Override public List<MediaType> getWritableMediaTypes()

{
    return MEDIA_TYPES;
}
org.springframework.http.codec.FormHttpMessageWriter

protected String serializeForm(MultiValueMap<String, String> formData, Charset charset)

{
    StringBuilder builder = new StringBuilder();
    formData.forEach((name, values) -> values.forEach(value -> {
        try {
            if (builder.length() != 0) {
                builder.append('&');
            } 
            builder.append(URLEncoder.encode(name, charset.name()));
            if (value != null) {
                builder.append('=');
                builder.append(URLEncoder.encode(value, charset.name()));
            } 
        } catch (UnsupportedEncodingException ex) {
            throw new IllegalStateException(ex);
        }
    }));
    return builder.toString();
}
org.springframework.http.codec.FormHttpMessageWriter

public void setDefaultCharset(Charset charset)

{
    Assert.notNull(charset, "Charset must not be null");
    this.defaultCharset = charset;
}

HttpMessageDecoder
inherit classes
  • Decoder<T>

HttpMessageEncoder
inherit classes
  • Encoder<T>

HttpMessageReader

HttpMessageWriter

LoggingCodecSupport

org.springframework.http.codec.LoggingCodecSupport

public boolean isEnableLoggingRequestDetails()

{
    return this.enableLoggingRequestDetails;
}
org.springframework.http.codec.LoggingCodecSupport

protected final Log logger

org.springframework.http.codec.LoggingCodecSupport

public void setEnableLoggingRequestDetails(boolean enable)

{
    this.enableLoggingRequestDetails = enable;
}

ResourceHttpMessageReader
extends DecoderHttpMessageReader<Resource>

org.springframework.http.codec.ResourceHttpMessageReader

public ResourceHttpMessageReader ResourceHttpMessageReader()

{
    super(new ResourceDecoder());
}
org.springframework.http.codec.ResourceHttpMessageReader

public ResourceHttpMessageReader ResourceHttpMessageReader(ResourceDecoder resourceDecoder)

{
    super(resourceDecoder);
}
org.springframework.http.codec.ResourceHttpMessageReader

@Override protected Map<String, Object> getReadHints(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response)

{
    String name = request.getHeaders().getContentDisposition().getFilename();
    return StringUtils.hasText(name) ? Hints.from(ResourceDecoder.FILENAME_HINT, name) : Hints.none();
}

ResourceHttpMessageWriter
implements HttpMessageWriter<Resource>

org.springframework.http.codec.ResourceHttpMessageWriter

public ResourceHttpMessageWriter ResourceHttpMessageWriter()

{
    this(ResourceEncoder.DEFAULT_BUFFER_SIZE);
}
org.springframework.http.codec.ResourceHttpMessageWriter

public ResourceHttpMessageWriter ResourceHttpMessageWriter(int bufferSize)

{
    this.encoder = new ResourceEncoder(bufferSize);
    this.regionEncoder = new ResourceRegionEncoder(bufferSize);
    this.mediaTypes = MediaType.asMediaTypes(this.encoder.getEncodableMimeTypes());
}
org.springframework.http.codec.ResourceHttpMessageWriter

@Override public boolean canWrite(ResolvableType elementType, @Nullable MediaType mediaType)

{
    return this.encoder.canEncode(elementType, mediaType);
}
org.springframework.http.codec.ResourceHttpMessageWriter

@Override public List<MediaType> getWritableMediaTypes()

{
    return this.mediaTypes;
}
org.springframework.http.codec.ResourceHttpMessageWriter

@Override public Mono<Void> write(Publisher<?> inputStream, ResolvableType elementType, @Nullable MediaType mediaType, ReactiveHttpOutputMessage message, Map<String, Object> hints)

{
    return Mono.from(inputStream).flatMap(resource -> writeResource(resource, elementType, mediaType, message, hints));
}
org.springframework.http.codec.ResourceHttpMessageWriter

@Override public Mono<Void> write(Publisher<?> inputStream, @Nullable ResolvableType actualType, ResolvableType elementType, @Nullable MediaType mediaType, ServerHttpRequest request, ServerHttpResponse response, Map<String, Object> hints)

{
    HttpHeaders headers = response.getHeaders();
    headers.set(HttpHeaders.ACCEPT_RANGES, "bytes");
    List < HttpRange > ranges;
    try {
        ranges = request.getHeaders().getRange();
    } catch (IllegalArgumentException ex) {
        response.setStatusCode(HttpStatus.REQUESTED_RANGE_NOT_SATISFIABLE);
        return response.setComplete();
    }
    return Mono.from(inputStream).flatMap(resource -> {
        if (ranges.isEmpty()) {
            return writeResource(resource, elementType, mediaType, response, hints);
        } 
        response.setStatusCode(HttpStatus.PARTIAL_CONTENT);
        List<ResourceRegion> regions = HttpRange.toResourceRegions(ranges, resource);
        MediaType resourceMediaType = getResourceMediaType(mediaType, resource, hints);
        if (regions.size() == 1) {
            ResourceRegion region = regions.get(0);
            headers.setContentType(resourceMediaType);
            long contentLength = lengthOf(resource);
            if (contentLength != -1) {
                long start = region.getPosition();
                long end = start + region.getCount() - 1;
                end = Math.min(end, contentLength - 1);
                headers.add("Content-Range", "bytes " + start + '-' + end + '/' + contentLength);
                headers.setContentLength(end - start + 1);
            } 
            return writeSingleRegion(region, response, hints);
        } else {
            String boundary = MimeTypeUtils.generateMultipartBoundaryString();
            MediaType multipartType = MediaType.parseMediaType("multipart/byteranges;boundary=" + boundary);
            headers.setContentType(multipartType);
            Map<String, Object> allHints = Hints.merge(hints, ResourceRegionEncoder.BOUNDARY_STRING_HINT, boundary);
            return encodeAndWriteRegions(Flux.fromIterable(regions), resourceMediaType, response, allHints);
        }
    });
}

ServerCodecConfigurer
inherit classes
  • CodecConfigurer

ServerSentEvent<T>

Builder
org.springframework.http.codec.ServerSentEvent

<T>public static Builder<T> builder()

{
    return new BuilderImpl<>();
}
org.springframework.http.codec.ServerSentEvent

<T>public static Builder<T> builder(T data)

{
    return new BuilderImpl<>(data);
}
org.springframework.http.codec.ServerSentEvent

@Nullable public String comment()

{
    return this.comment;
}
org.springframework.http.codec.ServerSentEvent

@Nullable public T data()

{
    return this.data;
}
org.springframework.http.codec.ServerSentEvent

@Nullable public String event()

{
    return this.event;
}
org.springframework.http.codec.ServerSentEvent

@Nullable public String id()

{
    return this.id;
}
org.springframework.http.codec.ServerSentEvent

@Nullable public Duration retry()

{
    return this.retry;
}

ServerSentEventHttpMessageReader
implements HttpMessageReader<Object>

org.springframework.http.codec.ServerSentEventHttpMessageReader

public ServerSentEventHttpMessageReader ServerSentEventHttpMessageReader()

{
    this(null);
}
org.springframework.http.codec.ServerSentEventHttpMessageReader

public ServerSentEventHttpMessageReader ServerSentEventHttpMessageReader(@Nullable Decoder<?> decoder)

{
    this.decoder = decoder;
}
org.springframework.http.codec.ServerSentEventHttpMessageReader

@Override public boolean canRead(ResolvableType elementType, @Nullable MediaType mediaType)

{
    return (MediaType.TEXT_EVENT_STREAM.includes(mediaType) || isServerSentEvent(elementType));
}
org.springframework.http.codec.ServerSentEventHttpMessageReader

@Nullable public Decoder<?> getDecoder()

{
    return this.decoder;
}
org.springframework.http.codec.ServerSentEventHttpMessageReader

@Override public List<MediaType> getReadableMediaTypes()

{
    return Collections.singletonList(MediaType.TEXT_EVENT_STREAM);
}
org.springframework.http.codec.ServerSentEventHttpMessageReader

@Override public Mono<Object> readMono(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String, Object> hints)

{
    if (elementType.resolve() == String.class) {
        Flux<DataBuffer> body = message.getBody();
        return stringDecoder.decodeToMono(body, elementType, null, null).cast(Object.class);
    } 
    return Mono.error(new UnsupportedOperationException("ServerSentEventHttpMessageReader only supports reading stream of events as a Flux"));
}

ServerSentEventHttpMessageWriter
implements HttpMessageWriter<Object>

org.springframework.http.codec.ServerSentEventHttpMessageWriter

public ServerSentEventHttpMessageWriter ServerSentEventHttpMessageWriter()

{
    this(null);
}
org.springframework.http.codec.ServerSentEventHttpMessageWriter

public ServerSentEventHttpMessageWriter ServerSentEventHttpMessageWriter(@Nullable Encoder<?> encoder)

{
    this.encoder = encoder;
}
org.springframework.http.codec.ServerSentEventHttpMessageWriter

@Override public boolean canWrite(ResolvableType elementType, @Nullable MediaType mediaType)

{
    return (mediaType == null || MediaType.TEXT_EVENT_STREAM.includes(mediaType) || ServerSentEvent.class.isAssignableFrom(elementType.toClass()));
}
org.springframework.http.codec.ServerSentEventHttpMessageWriter

@Nullable public Encoder<?> getEncoder()

{
    return this.encoder;
}
org.springframework.http.codec.ServerSentEventHttpMessageWriter

@Override public List<MediaType> getWritableMediaTypes()

{
    return WRITABLE_MEDIA_TYPES;
}
org.springframework.http.codec.ServerSentEventHttpMessageWriter

@Override public Mono<Void> write(Publisher<?> input, ResolvableType elementType, @Nullable MediaType mediaType, ReactiveHttpOutputMessage message, Map<String, Object> hints)

{
    mediaType = (mediaType != null && mediaType.getCharset() != null ? mediaType : DEFAULT_MEDIA_TYPE);
    DataBufferFactory bufferFactory = message.bufferFactory();
    message.getHeaders().setContentType(mediaType);
    return message.writeAndFlushWith(encode(input, elementType, mediaType, bufferFactory, hints));
}
org.springframework.http.codec.ServerSentEventHttpMessageWriter

@Override public Mono<Void> write(Publisher<?> input, ResolvableType actualType, ResolvableType elementType, @Nullable MediaType mediaType, ServerHttpRequest request, ServerHttpResponse response, Map<String, Object> hints)

{
    Map<String, Object> allHints = Hints.merge(hints, getEncodeHints(actualType, elementType, mediaType, request, response));
    return write(input, elementType, mediaType, response, allHints);
}

Jackson2CborDecoder
extends AbstractJackson2Decoder

org.springframework.http.codec.cbor.Jackson2CborDecoder

public Jackson2CborDecoder Jackson2CborDecoder()

{
    this(Jackson2ObjectMapperBuilder.cbor().build(), MediaType.APPLICATION_CBOR);
}
org.springframework.http.codec.cbor.Jackson2CborDecoder

public Jackson2CborDecoder Jackson2CborDecoder(ObjectMapper mapper, MimeType... mimeTypes)

{
    super(mapper, mimeTypes);
    Assert.isAssignable(CBORFactory.class, mapper.getFactory().getClass());
}
org.springframework.http.codec.cbor.Jackson2CborDecoder

@Override public Flux<Object> decode(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String, Object> hints)

{
    throw new UnsupportedOperationException("Does not support stream decoding yet");
}

Jackson2CborEncoder
extends AbstractJackson2Encoder

org.springframework.http.codec.cbor.Jackson2CborEncoder

public Jackson2CborEncoder Jackson2CborEncoder()

{
    this(Jackson2ObjectMapperBuilder.cbor().build(), MediaType.APPLICATION_CBOR);
}
org.springframework.http.codec.cbor.Jackson2CborEncoder

public Jackson2CborEncoder Jackson2CborEncoder(ObjectMapper mapper, MimeType... mimeTypes)

{
    super(mapper, mimeTypes);
    Assert.isAssignable(CBORFactory.class, mapper.getFactory().getClass());
}
org.springframework.http.codec.cbor.Jackson2CborEncoder

@Override public Flux<DataBuffer> encode(Publisher<?> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String, Object> hints)

{
    throw new UnsupportedOperationException("Does not support stream encoding yet");
}

AbstractJackson2Decoder
extends Jackson2CodecSupport implements HttpMessageDecoder<Object>

org.springframework.http.codec.json.AbstractJackson2Decoder

protected AbstractJackson2Decoder AbstractJackson2Decoder(ObjectMapper mapper, MimeType... mimeTypes)

{
    super(mapper, mimeTypes);
}
org.springframework.http.codec.json.AbstractJackson2Decoder

@Override public Object decode(DataBuffer dataBuffer, ResolvableType targetType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints)

{
    try {
        ObjectReader objectReader = getObjectReader(targetType, hints);
        Object value = objectReader.readValue(dataBuffer.asInputStream());
        logValue(value, hints);
        return value;
    } catch (IOException ex) {
        throw processException(ex);
    } finally {
        DataBufferUtils.release(dataBuffer);
    }
}
org.springframework.http.codec.json.AbstractJackson2Decoder

@Override public Mono<Object> decodeToMono(Publisher<DataBuffer> input, ResolvableType elementType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints)

{
    return DataBufferUtils.join(input).map(dataBuffer -> decode(dataBuffer, elementType, mimeType, hints));
}
org.springframework.http.codec.json.AbstractJackson2Decoder

<A>@Override protected A getAnnotation(MethodParameter parameter, Class<A> annotType)

{
    return parameter.getParameterAnnotation(annotType);
}
org.springframework.http.codec.json.AbstractJackson2Decoder

@Override public List<MimeType> getDecodableMimeTypes()

{
    return getMimeTypes();
}
org.springframework.http.codec.json.AbstractJackson2Decoder

@Override public Map<String, Object> getDecodeHints(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response)

{
    return getHints(actualType);
}

AbstractJackson2Encoder
extends Jackson2CodecSupport implements HttpMessageEncoder<Object>

org.springframework.http.codec.json.AbstractJackson2Encoder

protected AbstractJackson2Encoder AbstractJackson2Encoder(ObjectMapper mapper, MimeType... mimeTypes)

{
    super(mapper, mimeTypes);
}
org.springframework.http.codec.json.AbstractJackson2Encoder

@Override public boolean canEncode(ResolvableType elementType, @Nullable MimeType mimeType)

{
    Class<?> clazz = elementType.toClass();
    return supportsMimeType(mimeType) && (Object.class == clazz || (!String.class.isAssignableFrom(elementType.resolve(clazz)) && getObjectMapper().canSerialize(clazz)));
}
org.springframework.http.codec.json.AbstractJackson2Encoder

protected ObjectWriter customizeWriter(ObjectWriter writer, @Nullable MimeType mimeType, ResolvableType elementType, @Nullable Map<String, Object> hints)

{
    return writer;
}
org.springframework.http.codec.json.AbstractJackson2Encoder

@Override public DataBuffer encodeValue(Object value, DataBufferFactory bufferFactory, ResolvableType valueType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints)

{
    return encodeValue(value, bufferFactory, valueType, mimeType, hints, getJsonEncoding(mimeType));
}
org.springframework.http.codec.json.AbstractJackson2Encoder

<A>@Override protected A getAnnotation(MethodParameter parameter, Class<A> annotType)

{
    return parameter.getMethodAnnotation(annotType);
}
org.springframework.http.codec.json.AbstractJackson2Encoder

@Override public List<MimeType> getEncodableMimeTypes()

{
    return getMimeTypes();
}
org.springframework.http.codec.json.AbstractJackson2Encoder

@Override public Map<String, Object> getEncodeHints(@Nullable ResolvableType actualType, ResolvableType elementType, @Nullable MediaType mediaType, ServerHttpRequest request, ServerHttpResponse response)

{
    return (actualType != null ? getHints(actualType) : Hints.none());
}
org.springframework.http.codec.json.AbstractJackson2Encoder

protected JsonEncoding getJsonEncoding(@Nullable MimeType mimeType)

{
    if (mimeType != null && mimeType.getCharset() != null) {
        Charset charset = mimeType.getCharset();
        for (JsonEncoding encoding: JsonEncoding.values()) {
            if (charset.name().equals(encoding.getJavaName())) {
                return encoding;
            } 
        }
    } 
    return JsonEncoding.UTF8;
}
org.springframework.http.codec.json.AbstractJackson2Encoder

@Override public List<MediaType> getStreamingMediaTypes()

{
    return Collections.unmodifiableList(this.streamingMediaTypes);
}
org.springframework.http.codec.json.AbstractJackson2Encoder

public void setStreamingMediaTypes(List<MediaType> mediaTypes)

{
    this.streamingMediaTypes.clear();
    this.streamingMediaTypes.addAll(mediaTypes);
}

Jackson2CodecSupport

org.springframework.http.codec.json.Jackson2CodecSupport

public static final String JSON_VIEW_HINT

org.springframework.http.codec.json.Jackson2CodecSupport

protected Jackson2CodecSupport Jackson2CodecSupport(ObjectMapper objectMapper, MimeType... mimeTypes)

{
    Assert.notNull(objectMapper, "ObjectMapper must not be null");
    this.objectMapper = objectMapper;
    this.mimeTypes = !ObjectUtils.isEmpty(mimeTypes) ? Collections.unmodifiableList(Arrays.asList(mimeTypes)) : DEFAULT_MIME_TYPES;
}
org.springframework.http.codec.json.Jackson2CodecSupport

<A>@Nullable protected abstract A getAnnotation(MethodParameter parameter, Class<A> annotType)

org.springframework.http.codec.json.Jackson2CodecSupport

protected JavaType getJavaType(Type type, @Nullable Class<?> contextClass)

{
    TypeFactory typeFactory = this.objectMapper.getTypeFactory();
    return typeFactory.constructType(GenericTypeResolver.resolveType(type, contextClass));
}
org.springframework.http.codec.json.Jackson2CodecSupport

protected List<MimeType> getMimeTypes()

{
    return this.mimeTypes;
}
org.springframework.http.codec.json.Jackson2CodecSupport

public ObjectMapper getObjectMapper()

{
    return this.objectMapper;
}
org.springframework.http.codec.json.Jackson2CodecSupport

@Nullable protected MethodParameter getParameter(ResolvableType type)

{
    return (type.getSource() instanceof MethodParameter ? (MethodParameter)type.getSource() : null);
}
org.springframework.http.codec.json.Jackson2CodecSupport

protected final Log logger

org.springframework.http.codec.json.Jackson2CodecSupport

protected boolean supportsMimeType(@Nullable MimeType mimeType)

{
    return (mimeType == null || this.mimeTypes.stream().anyMatch(m -> m.isCompatibleWith(mimeType)));
}

Jackson2JsonDecoder
extends AbstractJackson2Decoder

org.springframework.http.codec.json.Jackson2JsonDecoder

public Jackson2JsonDecoder Jackson2JsonDecoder()

{
    super(Jackson2ObjectMapperBuilder.json().build());
}
org.springframework.http.codec.json.Jackson2JsonDecoder

public Jackson2JsonDecoder Jackson2JsonDecoder(ObjectMapper mapper, MimeType... mimeTypes)

{
    super(mapper, mimeTypes);
}

Jackson2JsonEncoder
extends AbstractJackson2Encoder

org.springframework.http.codec.json.Jackson2JsonEncoder

public Jackson2JsonEncoder Jackson2JsonEncoder()

{
    this(Jackson2ObjectMapperBuilder.json().build());
}
org.springframework.http.codec.json.Jackson2JsonEncoder

public Jackson2JsonEncoder Jackson2JsonEncoder(ObjectMapper mapper, MimeType... mimeTypes)

{
    super(mapper, mimeTypes);
    setStreamingMediaTypes(Collections.singletonList(MediaType.APPLICATION_STREAM_JSON));
    this.ssePrettyPrinter = initSsePrettyPrinter();
}
org.springframework.http.codec.json.Jackson2JsonEncoder

@Override protected ObjectWriter customizeWriter(ObjectWriter writer, @Nullable MimeType mimeType, ResolvableType elementType, @Nullable Map<String, Object> hints)

{
    return (this.ssePrettyPrinter != null && MediaType.TEXT_EVENT_STREAM.isCompatibleWith(mimeType) && writer.getConfig().isEnabled(SerializationFeature.INDENT_OUTPUT) ? writer.with(this.ssePrettyPrinter) : writer);
}

Jackson2SmileDecoder
extends AbstractJackson2Decoder

org.springframework.http.codec.json.Jackson2SmileDecoder

public Jackson2SmileDecoder Jackson2SmileDecoder()

{
    this(Jackson2ObjectMapperBuilder.smile().build(), DEFAULT_SMILE_MIME_TYPES);
}
org.springframework.http.codec.json.Jackson2SmileDecoder

public Jackson2SmileDecoder Jackson2SmileDecoder(ObjectMapper mapper, MimeType... mimeTypes)

{
    super(mapper, mimeTypes);
    Assert.isAssignable(SmileFactory.class, mapper.getFactory().getClass());
}

Jackson2SmileEncoder
extends AbstractJackson2Encoder

org.springframework.http.codec.json.Jackson2SmileEncoder

public Jackson2SmileEncoder Jackson2SmileEncoder()

{
    this(Jackson2ObjectMapperBuilder.smile().build(), DEFAULT_SMILE_MIME_TYPES);
}
org.springframework.http.codec.json.Jackson2SmileEncoder

public Jackson2SmileEncoder Jackson2SmileEncoder(ObjectMapper mapper, MimeType... mimeTypes)

{
    super(mapper, mimeTypes);
    Assert.isAssignable(SmileFactory.class, mapper.getFactory().getClass());
    setStreamingMediaTypes(Collections.singletonList(new MediaType("application", "stream+x-jackson-smile")));
}

Jackson2Tokenizer

org.springframework.http.codec.json.Jackson2Tokenizer

public static Flux<TokenBuffer> tokenize(Flux<DataBuffer> dataBuffers, JsonFactory jsonFactory, ObjectMapper objectMapper, boolean tokenizeArrayElements)

{
    try {
        JsonParser parser = jsonFactory.createNonBlockingByteArrayParser();
        DeserializationContext context = objectMapper.getDeserializationContext();
        if (context instanceof DefaultDeserializationContext) {
            context = ((DefaultDeserializationContext)context).createInstance(objectMapper.getDeserializationConfig(), parser, objectMapper.getInjectableValues());
        } 
        Jackson2Tokenizer tokenizer = new Jackson2Tokenizer(parser, context, tokenizeArrayElements);
        return dataBuffers.concatMapIterable(tokenizer::tokenize).concatWith(tokenizer.endOfInput());
    } catch (IOException ex) {
        return Flux.error(ex);
    }
}


FilePart
inherit classes
  • Part

FormFieldPart
inherit classes
  • Part

MultipartHttpMessageReader
extends LoggingCodecSupport implements HttpMessageReader<MultiValueMap<String, Part>>

org.springframework.http.codec.multipart.MultipartHttpMessageReader

public MultipartHttpMessageReader MultipartHttpMessageReader(HttpMessageReader<Part> partReader)

{
    Assert.notNull(partReader, "'partReader' is required");
    this.partReader = partReader;
}
org.springframework.http.codec.multipart.MultipartHttpMessageReader

@Override public boolean canRead(ResolvableType elementType, @Nullable MediaType mediaType)

{
    return MULTIPART_VALUE_TYPE.isAssignableFrom(elementType) && (mediaType == null || MediaType.MULTIPART_FORM_DATA.isCompatibleWith(mediaType));
}
org.springframework.http.codec.multipart.MultipartHttpMessageReader

@Override public List<MediaType> getReadableMediaTypes()

{
    return Collections.singletonList(MediaType.MULTIPART_FORM_DATA);
}
org.springframework.http.codec.multipart.MultipartHttpMessageReader

@Override public Flux<MultiValueMap<String, Part>> read(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String, Object> hints)

{
    return Flux.from(readMono(elementType, message, hints));
}

MultipartHttpMessageWriter
extends LoggingCodecSupport implements HttpMessageWriter<MultiValueMap<String, ?>>

org.springframework.http.codec.multipart.MultipartHttpMessageWriter

public static final Charset DEFAULT_CHARSET

org.springframework.http.codec.multipart.MultipartHttpMessageWriter

public MultipartHttpMessageWriter MultipartHttpMessageWriter()

{
    this(Arrays.asList(new EncoderHttpMessageWriter<>(CharSequenceEncoder.textPlainOnly()), new ResourceHttpMessageWriter()));
}
org.springframework.http.codec.multipart.MultipartHttpMessageWriter

public MultipartHttpMessageWriter MultipartHttpMessageWriter(List<HttpMessageWriter<?>> partWriters)

{
    this(partWriters, new FormHttpMessageWriter());
}
org.springframework.http.codec.multipart.MultipartHttpMessageWriter

public MultipartHttpMessageWriter MultipartHttpMessageWriter(List<HttpMessageWriter<?>> partWriters, @Nullable HttpMessageWriter<MultiValueMap<String, String>> formWriter)

{
    this.partWriters = partWriters;
    this.formWriter = formWriter;
    this.supportedMediaTypes = initMediaTypes(formWriter);
}
org.springframework.http.codec.multipart.MultipartHttpMessageWriter

@Override public boolean canWrite(ResolvableType elementType, @Nullable MediaType mediaType)

{
    return (MultiValueMap.class.isAssignableFrom(elementType.toClass()) && (mediaType == null || this.supportedMediaTypes.stream().anyMatch(element -> element.isCompatibleWith(mediaType))));
}
org.springframework.http.codec.multipart.MultipartHttpMessageWriter

protected byte[] generateMultipartBoundary()

{
    return MimeTypeUtils.generateMultipartBoundary();
}
org.springframework.http.codec.multipart.MultipartHttpMessageWriter

public Charset getCharset()

{
    return this.charset;
}
org.springframework.http.codec.multipart.MultipartHttpMessageWriter

public List<HttpMessageWriter<?>> getPartWriters()

{
    return Collections.unmodifiableList(this.partWriters);
}
org.springframework.http.codec.multipart.MultipartHttpMessageWriter

@Override public List<MediaType> getWritableMediaTypes()

{
    return this.supportedMediaTypes;
}
org.springframework.http.codec.multipart.MultipartHttpMessageWriter

public void setCharset(Charset charset)

{
    Assert.notNull(charset, "Charset must not be null");
    this.charset = charset;
}
org.springframework.http.codec.multipart.MultipartHttpMessageWriter

@Override public Mono<Void> write(Publisher<?> inputStream, ResolvableType elementType, @Nullable MediaType mediaType, ReactiveHttpOutputMessage outputMessage, Map<String, Object> hints)

{
    return Mono.from(inputStream).flatMap(map -> {
        if (this.formWriter == null || isMultipart(map, mediaType)) {
            return writeMultipart(map, outputMessage, hints);
        } else {
            @SuppressWarnings("unchecked") Mono<MultiValueMap<String, String>> input = Mono.just((MultiValueMap<String, String>)map);
            return this.formWriter.write(input, elementType, mediaType, outputMessage, hints);
        }
    });
}

Part

SynchronossPartHttpMessageReader
extends LoggingCodecSupport implements HttpMessageReader<Part>

org.springframework.http.codec.multipart.SynchronossPartHttpMessageReader

@Override public boolean canRead(ResolvableType elementType, @Nullable MediaType mediaType)

{
    return Part.class.equals(elementType.toClass()) && (mediaType == null || MediaType.MULTIPART_FORM_DATA.isCompatibleWith(mediaType));
}
org.springframework.http.codec.multipart.SynchronossPartHttpMessageReader

@Override public List<MediaType> getReadableMediaTypes()

{
    return Collections.singletonList(MediaType.MULTIPART_FORM_DATA);
}
org.springframework.http.codec.multipart.SynchronossPartHttpMessageReader

@Override public Mono<Part> readMono(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String, Object> hints)

{
    return Mono.error(new UnsupportedOperationException("Cannot read multipart request body into single Part"));
}



ProtobufCodecSupport

org.springframework.http.codec.protobuf.ProtobufCodecSupport

protected List<MimeType> getMimeTypes()

{
    return MIME_TYPES;
}
org.springframework.http.codec.protobuf.ProtobufCodecSupport

protected boolean supportsMimeType(@Nullable MimeType mimeType)

{
    return (mimeType == null || MIME_TYPES.stream().anyMatch(m -> m.isCompatibleWith(mimeType)));
}

ProtobufDecoder
extends ProtobufCodecSupport implements Decoder<Message>

org.springframework.http.codec.protobuf.ProtobufDecoder

protected static final int DEFAULT_MESSAGE_MAX_SIZE

org.springframework.http.codec.protobuf.ProtobufDecoder

public ProtobufDecoder ProtobufDecoder()

{
    this(ExtensionRegistry.newInstance());
}
org.springframework.http.codec.protobuf.ProtobufDecoder

public ProtobufDecoder ProtobufDecoder(ExtensionRegistry extensionRegistry)

{
    Assert.notNull(extensionRegistry, "ExtensionRegistry must not be null");
    this.extensionRegistry = extensionRegistry;
}
org.springframework.http.codec.protobuf.ProtobufDecoder

@Override public boolean canDecode(ResolvableType elementType, @Nullable MimeType mimeType)

{
    return Message.class.isAssignableFrom(elementType.toClass()) && supportsMimeType(mimeType);
}
org.springframework.http.codec.protobuf.ProtobufDecoder

@Override public Flux<Message> decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints)

{
    MessageDecoderFunction decoderFunction = new MessageDecoderFunction(elementType, this.maxMessageSize);
    return Flux.from(inputStream).flatMapIterable(decoderFunction).doOnTerminate(decoderFunction::discard);
}
org.springframework.http.codec.protobuf.ProtobufDecoder

@Override public Mono<Message> decodeToMono(Publisher<DataBuffer> inputStream, ResolvableType elementType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints)

{
    return DataBufferUtils.join(inputStream).map(dataBuffer -> decode(dataBuffer, elementType, mimeType, hints));
}
org.springframework.http.codec.protobuf.ProtobufDecoder

@Override public List<MimeType> getDecodableMimeTypes()

{
    return getMimeTypes();
}
org.springframework.http.codec.protobuf.ProtobufDecoder

public void setMaxMessageSize(int maxMessageSize)

{
    this.maxMessageSize = maxMessageSize;
}

ProtobufEncoder
extends ProtobufCodecSupport implements HttpMessageEncoder<Message>

org.springframework.http.codec.protobuf.ProtobufEncoder

@Override public boolean canEncode(ResolvableType elementType, @Nullable MimeType mimeType)

{
    return Message.class.isAssignableFrom(elementType.toClass()) && supportsMimeType(mimeType);
}
org.springframework.http.codec.protobuf.ProtobufEncoder

@Override public Flux<DataBuffer> encode(Publisher<?> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints)

{
    return Flux.from(inputStream).map(message -> encodeValue(message, bufferFactory, !(inputStream instanceof Mono)));
}
org.springframework.http.codec.protobuf.ProtobufEncoder

@Override public DataBuffer encodeValue(Message message, DataBufferFactory bufferFactory, ResolvableType valueType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints)

{
    return encodeValue(message, bufferFactory, false);
}
org.springframework.http.codec.protobuf.ProtobufEncoder

@Override public List<MimeType> getEncodableMimeTypes()

{
    return getMimeTypes();
}
org.springframework.http.codec.protobuf.ProtobufEncoder

@Override public List<MediaType> getStreamingMediaTypes()

{
    return streamingMediaTypes;
}

ProtobufHttpMessageWriter
extends EncoderHttpMessageWriter<Message>

org.springframework.http.codec.protobuf.ProtobufHttpMessageWriter

public ProtobufHttpMessageWriter ProtobufHttpMessageWriter()

{
    super(new ProtobufEncoder());
}
org.springframework.http.codec.protobuf.ProtobufHttpMessageWriter

public ProtobufHttpMessageWriter ProtobufHttpMessageWriter(Encoder<Message> encoder)

{
    super(encoder);
}


BaseCodecConfigurer
implements CodecConfigurer

org.springframework.http.codec.support.BaseCodecConfigurer

@Override public CustomCodecs customCodecs()

{
    return this.customCodecs;
}
org.springframework.http.codec.support.BaseCodecConfigurer

@Override public DefaultCodecs defaultCodecs()

{
    return this.defaultCodecs;
}
org.springframework.http.codec.support.BaseCodecConfigurer

@Override public List<HttpMessageWriter<?>> getWriters()

{
    return getWritersInternal(false);
}
org.springframework.http.codec.support.BaseCodecConfigurer

@Override public void registerDefaults(boolean shouldRegister)

{
    this.defaultCodecs.registerDefaults(shouldRegister);
}

BaseDefaultCodecs
implements CodecConfigurer.DefaultCodecs

org.springframework.http.codec.support.BaseDefaultCodecs

@Override public void enableLoggingRequestDetails(boolean enable)

{
    this.enableLoggingRequestDetails = enable;
}
org.springframework.http.codec.support.BaseDefaultCodecs

protected void extendObjectReaders(List<HttpMessageReader<?>> objectReaders)

{
}
org.springframework.http.codec.support.BaseDefaultCodecs

protected void extendObjectWriters(List<HttpMessageWriter<?>> objectWriters)

{
}
org.springframework.http.codec.support.BaseDefaultCodecs

protected void extendTypedReaders(List<HttpMessageReader<?>> typedReaders)

{
}
org.springframework.http.codec.support.BaseDefaultCodecs

protected void extendTypedWriters(List<HttpMessageWriter<?>> typedWriters)

{
}
org.springframework.http.codec.support.BaseDefaultCodecs

protected Decoder<?> getJackson2JsonDecoder()

{
    return (this.jackson2JsonDecoder != null ? this.jackson2JsonDecoder : new Jackson2JsonDecoder());
}
org.springframework.http.codec.support.BaseDefaultCodecs

protected Encoder<?> getJackson2JsonEncoder()

{
    return (this.jackson2JsonEncoder != null ? this.jackson2JsonEncoder : new Jackson2JsonEncoder());
}
org.springframework.http.codec.support.BaseDefaultCodecs

protected boolean isEnableLoggingRequestDetails()

{
    return this.enableLoggingRequestDetails;
}
org.springframework.http.codec.support.BaseDefaultCodecs

@Override public void jackson2JsonDecoder(Decoder<?> decoder)

{
    this.jackson2JsonDecoder = decoder;
}
org.springframework.http.codec.support.BaseDefaultCodecs

@Override public void jackson2JsonEncoder(Encoder<?> encoder)

{
    this.jackson2JsonEncoder = encoder;
}
org.springframework.http.codec.support.BaseDefaultCodecs

@Override public void jaxb2Decoder(Decoder<?> decoder)

{
    this.jaxb2Decoder = decoder;
}
org.springframework.http.codec.support.BaseDefaultCodecs

@Override public void jaxb2Encoder(Encoder<?> encoder)

{
    this.jaxb2Encoder = encoder;
}
org.springframework.http.codec.support.BaseDefaultCodecs

@Override public void protobufDecoder(Decoder<?> decoder)

{
    this.protobufDecoder = decoder;
}
org.springframework.http.codec.support.BaseDefaultCodecs

@Override public void protobufEncoder(Encoder<?> encoder)

{
    this.protobufEncoder = encoder;
}

ClientDefaultCodecsImpl
extends BaseDefaultCodecs implements ClientCodecConfigurer.ClientDefaultCodecs

org.springframework.http.codec.support.ClientDefaultCodecsImpl

@Override protected void extendObjectReaders(List<HttpMessageReader<?>> objectReaders)

{
    objectReaders.add(new ServerSentEventHttpMessageReader(getSseDecoder()));
}
org.springframework.http.codec.support.ClientDefaultCodecsImpl

@Override public ClientCodecConfigurer.MultipartCodecs multipartCodecs()

{
    if (this.multipartCodecs == null) {
        this.multipartCodecs = new DefaultMultipartCodecs();
    } 
    return this.multipartCodecs;
}
org.springframework.http.codec.support.ClientDefaultCodecsImpl

@Override public void serverSentEventDecoder(Decoder<?> decoder)

{
    this.sseDecoder = decoder;
}

DefaultClientCodecConfigurer
extends BaseCodecConfigurer implements ClientCodecConfigurer

org.springframework.http.codec.support.DefaultClientCodecConfigurer

public DefaultClientCodecConfigurer DefaultClientCodecConfigurer()

{
    super(new ClientDefaultCodecsImpl());
    ((ClientDefaultCodecsImpl)defaultCodecs()).setPartWritersSupplier(() -> getWritersInternal(true));
}
org.springframework.http.codec.support.DefaultClientCodecConfigurer

@Override public ClientDefaultCodecs defaultCodecs()

{
    return (ClientDefaultCodecs)super.defaultCodecs();
}

DefaultServerCodecConfigurer
extends BaseCodecConfigurer implements ServerCodecConfigurer

org.springframework.http.codec.support.DefaultServerCodecConfigurer

public DefaultServerCodecConfigurer DefaultServerCodecConfigurer()

{
    super(new ServerDefaultCodecsImpl());
}
org.springframework.http.codec.support.DefaultServerCodecConfigurer

@Override public ServerDefaultCodecs defaultCodecs()

{
    return (ServerDefaultCodecs)super.defaultCodecs();
}

ServerDefaultCodecsImpl
extends BaseDefaultCodecs implements ServerCodecConfigurer.ServerDefaultCodecs

org.springframework.http.codec.support.ServerDefaultCodecsImpl

@Override protected void extendObjectWriters(List<HttpMessageWriter<?>> objectWriters)

{
    objectWriters.add(new ServerSentEventHttpMessageWriter(getSseEncoder()));
}
org.springframework.http.codec.support.ServerDefaultCodecsImpl

@Override public void serverSentEventEncoder(Encoder<?> encoder)

{
    this.sseEncoder = encoder;
}


Jaxb2XmlDecoder
extends AbstractDecoder<Object>

org.springframework.http.codec.xml.Jaxb2XmlDecoder

public Jaxb2XmlDecoder Jaxb2XmlDecoder()

{
    super(MimeTypeUtils.APPLICATION_XML, MimeTypeUtils.TEXT_XML);
}
org.springframework.http.codec.xml.Jaxb2XmlDecoder

public Jaxb2XmlDecoder Jaxb2XmlDecoder(MimeType... supportedMimeTypes)

{
    super(supportedMimeTypes);
}
org.springframework.http.codec.xml.Jaxb2XmlDecoder

@Override public boolean canDecode(ResolvableType elementType, @Nullable MimeType mimeType)

{
    Class<?> outputClass = elementType.toClass();
    return (outputClass.isAnnotationPresent(XmlRootElement.class) || outputClass.isAnnotationPresent(XmlType.class)) && super.canDecode(elementType, mimeType);
}
org.springframework.http.codec.xml.Jaxb2XmlDecoder

@Override @SuppressWarnings({"rawtypes","unchecked","cast"}) public Object decode(DataBuffer dataBuffer, ResolvableType targetType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints)

{
    try {
        Iterator eventReader = inputFactory.createXMLEventReader(dataBuffer.asInputStream());
        List<XMLEvent> events = new ArrayList<>();
        eventReader.forEachRemaining(event -> events.add((XMLEvent)event));
        return unmarshal(events, targetType.toClass());
    } catch (XMLStreamException ex) {
        throw Exceptions.propagate(ex);
    } finally {
        DataBufferUtils.release(dataBuffer);
    }
}
org.springframework.http.codec.xml.Jaxb2XmlDecoder

@Override @SuppressWarnings({"rawtypes","unchecked","cast"}) public Mono<Object> decodeToMono(Publisher<DataBuffer> input, ResolvableType elementType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints)

{
    return DataBufferUtils.join(input).map(dataBuffer -> decode(dataBuffer, elementType, mimeType, hints));
}
org.springframework.http.codec.xml.Jaxb2XmlDecoder

public Function<Unmarshaller, Unmarshaller> getUnmarshallerProcessor()

{
    return this.unmarshallerProcessor;
}
org.springframework.http.codec.xml.Jaxb2XmlDecoder

public void setUnmarshallerProcessor(Function<Unmarshaller, Unmarshaller> processor)

{
    this.unmarshallerProcessor = this.unmarshallerProcessor.andThen(processor);
}

Jaxb2XmlEncoder
extends AbstractSingleValueEncoder<Object>

org.springframework.http.codec.xml.Jaxb2XmlEncoder

public Jaxb2XmlEncoder Jaxb2XmlEncoder()

{
    super(MimeTypeUtils.APPLICATION_XML, MimeTypeUtils.TEXT_XML);
}
org.springframework.http.codec.xml.Jaxb2XmlEncoder

@Override protected Flux<DataBuffer> encode(Object value, DataBufferFactory bufferFactory, ResolvableType valueType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints)

{
    return Mono.fromCallable(() -> encodeValue(value, bufferFactory, valueType, mimeType, hints)).flux();
}
org.springframework.http.codec.xml.Jaxb2XmlEncoder

public Function<Marshaller, Marshaller> getMarshallerProcessor()

{
    return this.marshallerProcessor;
}
org.springframework.http.codec.xml.Jaxb2XmlEncoder

public void setMarshallerProcessor(Function<Marshaller, Marshaller> processor)

{
    this.marshallerProcessor = this.marshallerProcessor.andThen(processor);
}

JaxbContextContainer

org.springframework.http.codec.xml.JaxbContextContainer

public Marshaller createMarshaller(Class<?> clazz)

{
    JAXBContext jaxbContext = getJaxbContext(clazz);
    return jaxbContext.createMarshaller();
}
org.springframework.http.codec.xml.JaxbContextContainer

public Unmarshaller createUnmarshaller(Class<?> clazz)

{
    JAXBContext jaxbContext = getJaxbContext(clazz);
    return jaxbContext.createUnmarshaller();
}

XmlEventDecoder
extends AbstractDecoder<XMLEvent>

org.springframework.http.codec.xml.XmlEventDecoder

public XmlEventDecoder XmlEventDecoder()

{
    super(MimeTypeUtils.APPLICATION_XML, MimeTypeUtils.TEXT_XML);
}


AbstractGenericHttpMessageConverter<T>
extends AbstractHttpMessageConverter<T> implements GenericHttpMessageConverter<T>

org.springframework.http.converter.AbstractGenericHttpMessageConverter

protected AbstractGenericHttpMessageConverter AbstractGenericHttpMessageConverter()

{
}
org.springframework.http.converter.AbstractGenericHttpMessageConverter

protected AbstractGenericHttpMessageConverter AbstractGenericHttpMessageConverter(MediaType supportedMediaType)

{
    super(supportedMediaType);
}
org.springframework.http.converter.AbstractGenericHttpMessageConverter

protected AbstractGenericHttpMessageConverter AbstractGenericHttpMessageConverter(MediaType... supportedMediaTypes)

{
    super(supportedMediaTypes);
}
org.springframework.http.converter.AbstractGenericHttpMessageConverter

@Override public boolean canRead(Type type, @Nullable Class<?> contextClass, @Nullable MediaType mediaType)

{
    return (type instanceof Class ? canRead((Class<?>)type, mediaType) : canRead(mediaType));
}
org.springframework.http.converter.AbstractGenericHttpMessageConverter

@Override public boolean canWrite(@Nullable Type type, Class<?> clazz, @Nullable MediaType mediaType)

{
    return canWrite(clazz, mediaType);
}
org.springframework.http.converter.AbstractGenericHttpMessageConverter

@Override protected boolean supports(Class<?> clazz)

{
    return true;
}
org.springframework.http.converter.AbstractGenericHttpMessageConverter

@Override protected void writeInternal(T t, HttpOutputMessage outputMessage)

{
    writeInternal(t, null, outputMessage);
}
org.springframework.http.converter.AbstractGenericHttpMessageConverter

protected abstract void writeInternal(T t, @Nullable Type type, HttpOutputMessage outputMessage)


AbstractHttpMessageConverter<T>
implements HttpMessageConverter<T>

org.springframework.http.converter.AbstractHttpMessageConverter

protected AbstractHttpMessageConverter AbstractHttpMessageConverter()

{
}
org.springframework.http.converter.AbstractHttpMessageConverter

protected AbstractHttpMessageConverter AbstractHttpMessageConverter(MediaType supportedMediaType)

{
    setSupportedMediaTypes(Collections.singletonList(supportedMediaType));
}
org.springframework.http.converter.AbstractHttpMessageConverter

protected AbstractHttpMessageConverter AbstractHttpMessageConverter(MediaType... supportedMediaTypes)

{
    setSupportedMediaTypes(Arrays.asList(supportedMediaTypes));
}
org.springframework.http.converter.AbstractHttpMessageConverter

protected AbstractHttpMessageConverter AbstractHttpMessageConverter(Charset defaultCharset, MediaType... supportedMediaTypes)

{
    this.defaultCharset = defaultCharset;
    setSupportedMediaTypes(Arrays.asList(supportedMediaTypes));
}
org.springframework.http.converter.AbstractHttpMessageConverter

@Override public boolean canRead(Class<?> clazz, @Nullable MediaType mediaType)

{
    return supports(clazz) && canRead(mediaType);
}
org.springframework.http.converter.AbstractHttpMessageConverter

protected boolean canRead(@Nullable MediaType mediaType)

{
    if (mediaType == null) {
        return true;
    } 
    for (MediaType supportedMediaType: getSupportedMediaTypes()) {
        if (supportedMediaType.includes(mediaType)) {
            return true;
        } 
    }
    return false;
}
org.springframework.http.converter.AbstractHttpMessageConverter

@Override public boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType)

{
    return supports(clazz) && canWrite(mediaType);
}
org.springframework.http.converter.AbstractHttpMessageConverter

protected boolean canWrite(@Nullable MediaType mediaType)

{
    if (mediaType == null || MediaType.ALL.equalsTypeAndSubtype(mediaType)) {
        return true;
    } 
    for (MediaType supportedMediaType: getSupportedMediaTypes()) {
        if (supportedMediaType.isCompatibleWith(mediaType)) {
            return true;
        } 
    }
    return false;
}
org.springframework.http.converter.AbstractHttpMessageConverter

@Nullable protected Long getContentLength(T t, @Nullable MediaType contentType)

{
    return null;
}
org.springframework.http.converter.AbstractHttpMessageConverter

@Nullable public Charset getDefaultCharset()

{
    return this.defaultCharset;
}
org.springframework.http.converter.AbstractHttpMessageConverter

@Nullable protected MediaType getDefaultContentType(T t)

{
    List<MediaType> mediaTypes = getSupportedMediaTypes();
    return (!mediaTypes.isEmpty() ? mediaTypes.get(0) : null);
}
org.springframework.http.converter.AbstractHttpMessageConverter

@Override public List<MediaType> getSupportedMediaTypes()

{
    return Collections.unmodifiableList(this.supportedMediaTypes);
}
org.springframework.http.converter.AbstractHttpMessageConverter

protected final Log logger

org.springframework.http.converter.AbstractHttpMessageConverter

@Override public final T read(Class<?> clazz, HttpInputMessage inputMessage)

{
    return readInternal(clazz, inputMessage);
}
org.springframework.http.converter.AbstractHttpMessageConverter

protected abstract T readInternal(Class<?> clazz, HttpInputMessage inputMessage)

org.springframework.http.converter.AbstractHttpMessageConverter

public void setDefaultCharset(@Nullable Charset defaultCharset)

{
    this.defaultCharset = defaultCharset;
}
org.springframework.http.converter.AbstractHttpMessageConverter

public void setSupportedMediaTypes(List<MediaType> supportedMediaTypes)

{
    Assert.notEmpty(supportedMediaTypes, "MediaType List must not be empty");
    this.supportedMediaTypes = new ArrayList<>(supportedMediaTypes);
}
org.springframework.http.converter.AbstractHttpMessageConverter

protected abstract boolean supports(Class<?> clazz)

org.springframework.http.converter.AbstractHttpMessageConverter

protected abstract void writeInternal(T t, HttpOutputMessage outputMessage)


BufferedImageHttpMessageConverter
implements HttpMessageConverter<BufferedImage>

org.springframework.http.converter.BufferedImageHttpMessageConverter

public BufferedImageHttpMessageConverter BufferedImageHttpMessageConverter()

{
    String[] readerMediaTypes = ImageIO.getReaderMIMETypes();
    for (String mediaType: readerMediaTypes) {
        if (StringUtils.hasText(mediaType)) {
            this.readableMediaTypes.add(MediaType.parseMediaType(mediaType));
        } 
    }
    String[] writerMediaTypes = ImageIO.getWriterMIMETypes();
    for (String mediaType: writerMediaTypes) {
        if (StringUtils.hasText(mediaType)) {
            this.defaultContentType = MediaType.parseMediaType(mediaType);
            break;
        } 
    }
}
org.springframework.http.converter.BufferedImageHttpMessageConverter

@Override public boolean canRead(Class<?> clazz, @Nullable MediaType mediaType)

{
    return (BufferedImage.class == clazz && isReadable(mediaType));
}
org.springframework.http.converter.BufferedImageHttpMessageConverter

@Override public boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType)

{
    return (BufferedImage.class == clazz && isWritable(mediaType));
}
org.springframework.http.converter.BufferedImageHttpMessageConverter

@Nullable public MediaType getDefaultContentType()

{
    return this.defaultContentType;
}
org.springframework.http.converter.BufferedImageHttpMessageConverter

@Override public List<MediaType> getSupportedMediaTypes()

{
    return Collections.unmodifiableList(this.readableMediaTypes);
}
org.springframework.http.converter.BufferedImageHttpMessageConverter

protected void process(ImageReadParam irp)

{
}
org.springframework.http.converter.BufferedImageHttpMessageConverter

protected void process(ImageWriteParam iwp)

{
}
org.springframework.http.converter.BufferedImageHttpMessageConverter

public void setCacheDir(File cacheDir)

{
    Assert.notNull(cacheDir, "'cacheDir' must not be null");
    Assert.isTrue(cacheDir.isDirectory(), "'cacheDir' is not a directory");
    this.cacheDir = cacheDir;
}

ByteArrayHttpMessageConverter
extends AbstractHttpMessageConverter<byte[]>

org.springframework.http.converter.ByteArrayHttpMessageConverter

public ByteArrayHttpMessageConverter ByteArrayHttpMessageConverter()

{
    super(MediaType.APPLICATION_OCTET_STREAM, MediaType.ALL);
}
org.springframework.http.converter.ByteArrayHttpMessageConverter

@Override protected Long getContentLength(byte[] bytes, @Nullable MediaType contentType)

{
    return (long)bytes.length;
}
org.springframework.http.converter.ByteArrayHttpMessageConverter

@Override public boolean supports(Class<?> clazz)

{
    return byte[].class == clazz;
}
org.springframework.http.converter.ByteArrayHttpMessageConverter

@Override protected void writeInternal(byte[] bytes, HttpOutputMessage outputMessage)

{
    StreamUtils.copy(bytes, outputMessage.getBody());
}

FormHttpMessageConverter
implements HttpMessageConverter<MultiValueMap<String, ?>>

org.springframework.http.converter.FormHttpMessageConverter

public static final Charset DEFAULT_CHARSET

org.springframework.http.converter.FormHttpMessageConverter

public void addPartConverter(HttpMessageConverter<?> partConverter)

{
    Assert.notNull(partConverter, "'partConverter' must not be null");
    this.partConverters.add(partConverter);
}
org.springframework.http.converter.FormHttpMessageConverter

@Override public boolean canRead(Class<?> clazz, @Nullable MediaType mediaType)

{
    if (!MultiValueMap.class.isAssignableFrom(clazz)) {
        return false;
    } 
    if (mediaType == null) {
        return true;
    } 
    for (MediaType supportedMediaType: getSupportedMediaTypes()) {
        if (MULTIPART_ALL.includes(supportedMediaType)) {
            continue;
        } 
        if (supportedMediaType.includes(mediaType)) {
            return true;
        } 
    }
    return false;
}
org.springframework.http.converter.FormHttpMessageConverter

@Override public boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType)

{
    if (!MultiValueMap.class.isAssignableFrom(clazz)) {
        return false;
    } 
    if (mediaType == null || MediaType.ALL.equals(mediaType)) {
        return true;
    } 
    for (MediaType supportedMediaType: getSupportedMediaTypes()) {
        if (supportedMediaType.isCompatibleWith(mediaType)) {
            return true;
        } 
    }
    return false;
}
org.springframework.http.converter.FormHttpMessageConverter

protected byte[] generateMultipartBoundary()

{
    return MimeTypeUtils.generateMultipartBoundary();
}
org.springframework.http.converter.FormHttpMessageConverter

protected HttpEntity<?> getHttpEntity(Object part)

{
    return (part instanceof HttpEntity ? (HttpEntity<?>)part : new HttpEntity<>(part));
}
org.springframework.http.converter.FormHttpMessageConverter

@Override public List<MediaType> getSupportedMediaTypes()

{
    return Collections.unmodifiableList(this.supportedMediaTypes);
}
org.springframework.http.converter.FormHttpMessageConverter

protected String serializeForm(MultiValueMap<String, Object> formData, Charset charset)

{
    StringBuilder builder = new StringBuilder();
    formData.forEach((name, values) -> values.forEach(value -> {
        try {
            if (builder.length() != 0) {
                builder.append('&');
            } 
            builder.append(URLEncoder.encode(name, charset.name()));
            if (value != null) {
                builder.append('=');
                builder.append(URLEncoder.encode(String.valueOf(value), charset.name()));
            } 
        } catch (UnsupportedEncodingException ex) {
            throw new IllegalStateException(ex);
        }
    }));
    return builder.toString();
}
org.springframework.http.converter.FormHttpMessageConverter

public void setCharset(@Nullable Charset charset)

{
    if (charset != this.charset) {
        this.charset = (charset != null ? charset : DEFAULT_CHARSET);
        applyDefaultCharset();
    } 
}
org.springframework.http.converter.FormHttpMessageConverter

public void setMultipartCharset(Charset charset)

{
    this.multipartCharset = charset;
}
org.springframework.http.converter.FormHttpMessageConverter

public void setPartConverters(List<HttpMessageConverter<?>> partConverters)

{
    Assert.notEmpty(partConverters, "'partConverters' must not be empty");
    this.partConverters = partConverters;
}
org.springframework.http.converter.FormHttpMessageConverter

public void setSupportedMediaTypes(List<MediaType> supportedMediaTypes)

{
    Assert.notNull(supportedMediaTypes, "'supportedMediaTypes' must not be null");
    this.supportedMediaTypes = new ArrayList<>(supportedMediaTypes);
}
org.springframework.http.converter.FormHttpMessageConverter

@Override @SuppressWarnings("unchecked") public void write(MultiValueMap<String, ?> map, @Nullable MediaType contentType, HttpOutputMessage outputMessage)

{
    if (isMultipart(map, contentType)) {
        writeMultipart((MultiValueMap<String, Object>)map, contentType, outputMessage);
    } else {
        writeForm((MultiValueMap<String, Object>)map, contentType, outputMessage);
    }
}

GenericHttpMessageConverter
inherit classes
  • HttpMessageConverter<T>

HttpMessageConversionException
extends NestedRuntimeException

org.springframework.http.converter.HttpMessageConversionException

public HttpMessageConversionException HttpMessageConversionException(String msg)

{
    super(msg);
}
org.springframework.http.converter.HttpMessageConversionException

public HttpMessageConversionException HttpMessageConversionException(String msg, @Nullable Throwable cause)

{
    super(msg, cause);
}

HttpMessageConverter

HttpMessageNotReadableException
extends HttpMessageConversionException

org.springframework.http.converter.HttpMessageNotReadableException

@Deprecated public HttpMessageNotReadableException HttpMessageNotReadableException(String msg)

{
    super(msg);
    this.httpInputMessage = null;
}
org.springframework.http.converter.HttpMessageNotReadableException

@Deprecated public HttpMessageNotReadableException HttpMessageNotReadableException(String msg, @Nullable Throwable cause)

{
    super(msg, cause);
    this.httpInputMessage = null;
}
org.springframework.http.converter.HttpMessageNotReadableException

public HttpMessageNotReadableException HttpMessageNotReadableException(String msg, HttpInputMessage httpInputMessage)

{
    super(msg);
    this.httpInputMessage = httpInputMessage;
}
org.springframework.http.converter.HttpMessageNotReadableException

public HttpMessageNotReadableException HttpMessageNotReadableException(String msg, @Nullable Throwable cause, HttpInputMessage httpInputMessage)

{
    super(msg, cause);
    this.httpInputMessage = httpInputMessage;
}
org.springframework.http.converter.HttpMessageNotReadableException

public HttpInputMessage getHttpInputMessage()

{
    Assert.state(this.httpInputMessage != null, "No HttpInputMessage available - use non-deprecated constructors");
    return this.httpInputMessage;
}

HttpMessageNotWritableException
extends HttpMessageConversionException

org.springframework.http.converter.HttpMessageNotWritableException

public HttpMessageNotWritableException HttpMessageNotWritableException(String msg)

{
    super(msg);
}
org.springframework.http.converter.HttpMessageNotWritableException

public HttpMessageNotWritableException HttpMessageNotWritableException(String msg, @Nullable Throwable cause)

{
    super(msg, cause);
}

ObjectToStringHttpMessageConverter
extends AbstractHttpMessageConverter<Object>

org.springframework.http.converter.ObjectToStringHttpMessageConverter

public ObjectToStringHttpMessageConverter ObjectToStringHttpMessageConverter(ConversionService conversionService)

{
    this(conversionService, StringHttpMessageConverter.DEFAULT_CHARSET);
}
org.springframework.http.converter.ObjectToStringHttpMessageConverter

public ObjectToStringHttpMessageConverter ObjectToStringHttpMessageConverter(ConversionService conversionService, Charset defaultCharset)

{
    super(defaultCharset, MediaType.TEXT_PLAIN);
    Assert.notNull(conversionService, "ConversionService is required");
    this.conversionService = conversionService;
    this.stringHttpMessageConverter = new StringHttpMessageConverter(defaultCharset);
}
org.springframework.http.converter.ObjectToStringHttpMessageConverter

@Override public boolean canRead(Class<?> clazz, @Nullable MediaType mediaType)

{
    return canRead(mediaType) && this.conversionService.canConvert(String.class, clazz);
}
org.springframework.http.converter.ObjectToStringHttpMessageConverter

@Override public boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType)

{
    return canWrite(mediaType) && this.conversionService.canConvert(clazz, String.class);
}
org.springframework.http.converter.ObjectToStringHttpMessageConverter

@Override protected Long getContentLength(Object obj, @Nullable MediaType contentType)

{
    String value = this.conversionService.convert(obj, String.class);
    if (value == null) {
        return 0L;
    } 
    return this.stringHttpMessageConverter.getContentLength(value, contentType);
}
org.springframework.http.converter.ObjectToStringHttpMessageConverter

public void setWriteAcceptCharset(boolean writeAcceptCharset)

{
    this.stringHttpMessageConverter.setWriteAcceptCharset(writeAcceptCharset);
}
org.springframework.http.converter.ObjectToStringHttpMessageConverter

@Override protected boolean supports(Class<?> clazz)

{
    throw new UnsupportedOperationException();
}
org.springframework.http.converter.ObjectToStringHttpMessageConverter

@Override protected void writeInternal(Object obj, HttpOutputMessage outputMessage)

{
    String value = this.conversionService.convert(obj, String.class);
    if (value != null) {
        this.stringHttpMessageConverter.writeInternal(value, outputMessage);
    } 
}

ResourceHttpMessageConverter
extends AbstractHttpMessageConverter<Resource>

org.springframework.http.converter.ResourceHttpMessageConverter

public ResourceHttpMessageConverter ResourceHttpMessageConverter()

{
    super(MediaType.ALL);
    this.supportsReadStreaming = true;
}
org.springframework.http.converter.ResourceHttpMessageConverter

public ResourceHttpMessageConverter ResourceHttpMessageConverter(boolean supportsReadStreaming)

{
    super(MediaType.ALL);
    this.supportsReadStreaming = supportsReadStreaming;
}
org.springframework.http.converter.ResourceHttpMessageConverter

@Override protected Long getContentLength(Resource resource, @Nullable MediaType contentType)

{
    if (InputStreamResource.class == resource.getClass()) {
        return null;
    } 
    long contentLength = resource.contentLength();
    return (contentLength < 0 ? null : contentLength);
}
org.springframework.http.converter.ResourceHttpMessageConverter

@Override protected MediaType getDefaultContentType(Resource resource)

{
    return MediaTypeFactory.getMediaType(resource).orElse(MediaType.APPLICATION_OCTET_STREAM);
}
org.springframework.http.converter.ResourceHttpMessageConverter

@Override protected boolean supports(Class<?> clazz)

{
    return Resource.class.isAssignableFrom(clazz);
}
org.springframework.http.converter.ResourceHttpMessageConverter

protected void writeContent(Resource resource, HttpOutputMessage outputMessage)

{
    try {
        InputStream in = resource.getInputStream();
        try {
            StreamUtils.copy(in, outputMessage.getBody());
        } catch (NullPointerException ex) {
        } finally {
            try {
                in.close();
            } catch (Throwable ex) {
            }
        }
    } catch (FileNotFoundException ex) {
    }
}
org.springframework.http.converter.ResourceHttpMessageConverter

@Override protected void writeInternal(Resource resource, HttpOutputMessage outputMessage)

{
    writeContent(resource, outputMessage);
}

ResourceRegionHttpMessageConverter
extends AbstractGenericHttpMessageConverter<Object>

org.springframework.http.converter.ResourceRegionHttpMessageConverter

public ResourceRegionHttpMessageConverter ResourceRegionHttpMessageConverter()

{
    super(MediaType.ALL);
}
org.springframework.http.converter.ResourceRegionHttpMessageConverter

@Override public boolean canRead(Class<?> clazz, @Nullable MediaType mediaType)

{
    return false;
}
org.springframework.http.converter.ResourceRegionHttpMessageConverter

@Override public boolean canRead(Type type, @Nullable Class<?> contextClass, @Nullable MediaType mediaType)

{
    return false;
}
org.springframework.http.converter.ResourceRegionHttpMessageConverter

@Override public boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType)

{
    return canWrite(clazz, null, mediaType);
}
org.springframework.http.converter.ResourceRegionHttpMessageConverter

@Override public boolean canWrite(@Nullable Type type, @Nullable Class<?> clazz, @Nullable MediaType mediaType)

{
    if (!(type instanceof ParameterizedType)) {
        return (type instanceof Class && ResourceRegion.class.isAssignableFrom((Class<?>)type));
    } 
    ParameterizedType parameterizedType = (ParameterizedType)type;
    if (!(parameterizedType.getRawType() instanceof Class)) {
        return false;
    } 
    Class<?> rawType = (Class<?>)parameterizedType.getRawType();
    if (!(Collection.class.isAssignableFrom(rawType))) {
        return false;
    } 
    if (parameterizedType.getActualTypeArguments().length != 1) {
        return false;
    } 
    Type typeArgument = parameterizedType.getActualTypeArguments()[0];
    if (!(typeArgument instanceof Class)) {
        return false;
    } 
    Class<?> typeArgumentClass = (Class<?>)typeArgument;
    return ResourceRegion.class.isAssignableFrom(typeArgumentClass);
}
org.springframework.http.converter.ResourceRegionHttpMessageConverter

@Override @SuppressWarnings("unchecked") protected MediaType getDefaultContentType(Object object)

{
    Resource resource = null;
    if (object instanceof ResourceRegion) {
        resource = ((ResourceRegion)object).getResource();
    } else {
        Collection<ResourceRegion> regions = (Collection<ResourceRegion>)object;
        if (!regions.isEmpty()) {
            resource = regions.iterator().next().getResource();
        } 
    }
    return MediaTypeFactory.getMediaType(resource).orElse(MediaType.APPLICATION_OCTET_STREAM);
}
org.springframework.http.converter.ResourceRegionHttpMessageConverter

@Override public Object read(Type type, @Nullable Class<?> contextClass, HttpInputMessage inputMessage)

{
    throw new UnsupportedOperationException();
}
org.springframework.http.converter.ResourceRegionHttpMessageConverter

@Override protected ResourceRegion readInternal(Class<?> clazz, HttpInputMessage inputMessage)

{
    throw new UnsupportedOperationException();
}

StringHttpMessageConverter
extends AbstractHttpMessageConverter<String>

org.springframework.http.converter.StringHttpMessageConverter

public static final Charset DEFAULT_CHARSET

org.springframework.http.converter.StringHttpMessageConverter

public StringHttpMessageConverter StringHttpMessageConverter()

{
    this(DEFAULT_CHARSET);
}
org.springframework.http.converter.StringHttpMessageConverter

public StringHttpMessageConverter StringHttpMessageConverter(Charset defaultCharset)

{
    super(defaultCharset, MediaType.TEXT_PLAIN, MediaType.ALL);
}
org.springframework.http.converter.StringHttpMessageConverter

@Nullable volatile List<Charset> availableCharsets

org.springframework.http.converter.StringHttpMessageConverter

protected List<Charset> getAcceptedCharsets()

{
    List<Charset> charsets = this.availableCharsets;
    if (charsets == null) {
        charsets = new ArrayList<>(Charset.availableCharsets().values());
        this.availableCharsets = charsets;
    } 
    return charsets;
}
org.springframework.http.converter.StringHttpMessageConverter

@Override protected Long getContentLength(String str, @Nullable MediaType contentType)

{
    Charset charset = getContentTypeCharset(contentType);
    return (long)str.getBytes(charset).length;
}
org.springframework.http.converter.StringHttpMessageConverter

@Override protected String readInternal(Class<?> clazz, HttpInputMessage inputMessage)

{
    Charset charset = getContentTypeCharset(inputMessage.getHeaders().getContentType());
    return StreamUtils.copyToString(inputMessage.getBody(), charset);
}
org.springframework.http.converter.StringHttpMessageConverter

public void setWriteAcceptCharset(boolean writeAcceptCharset)

{
    this.writeAcceptCharset = writeAcceptCharset;
}
org.springframework.http.converter.StringHttpMessageConverter

@Override public boolean supports(Class<?> clazz)

{
    return String.class == clazz;
}
org.springframework.http.converter.StringHttpMessageConverter

@Override protected void writeInternal(String str, HttpOutputMessage outputMessage)

{
    HttpHeaders headers = outputMessage.getHeaders();
    if (this.writeAcceptCharset && headers.get(HttpHeaders.ACCEPT_CHARSET) == null) {
        headers.setAcceptCharset(getAcceptedCharsets());
    } 
    Charset charset = getContentTypeCharset(headers.getContentType());
    StreamUtils.copy(str, charset, outputMessage.getBody());
}

MappingJackson2CborHttpMessageConverter
extends AbstractJackson2HttpMessageConverter

org.springframework.http.converter.cbor.MappingJackson2CborHttpMessageConverter

public MappingJackson2CborHttpMessageConverter MappingJackson2CborHttpMessageConverter()

{
    this(Jackson2ObjectMapperBuilder.cbor().build());
}
org.springframework.http.converter.cbor.MappingJackson2CborHttpMessageConverter

public MappingJackson2CborHttpMessageConverter MappingJackson2CborHttpMessageConverter(ObjectMapper objectMapper)

{
    super(objectMapper, MediaType.APPLICATION_CBOR);
    Assert.isInstanceOf(CBORFactory.class, objectMapper.getFactory(), "CBORFactory required");
}
org.springframework.http.converter.cbor.MappingJackson2CborHttpMessageConverter

@Override public void setObjectMapper(ObjectMapper objectMapper)

{
    Assert.isInstanceOf(CBORFactory.class, objectMapper.getFactory(), "CBORFactory required");
    super.setObjectMapper(objectMapper);
}


AbstractWireFeedHttpMessageConverter<T>
extends AbstractHttpMessageConverter<T>

org.springframework.http.converter.feed.AbstractWireFeedHttpMessageConverter

protected AbstractWireFeedHttpMessageConverter AbstractWireFeedHttpMessageConverter(MediaType supportedMediaType)

{
    super(supportedMediaType);
}
org.springframework.http.converter.feed.AbstractWireFeedHttpMessageConverter

public static final Charset DEFAULT_CHARSET


AtomFeedHttpMessageConverter
extends AbstractWireFeedHttpMessageConverter<Feed>

org.springframework.http.converter.feed.AtomFeedHttpMessageConverter

public AtomFeedHttpMessageConverter AtomFeedHttpMessageConverter()

{
    super(new MediaType("application", "atom+xml"));
}
org.springframework.http.converter.feed.AtomFeedHttpMessageConverter

@Override protected boolean supports(Class<?> clazz)

{
    return Feed.class.isAssignableFrom(clazz);
}

RssChannelHttpMessageConverter
extends AbstractWireFeedHttpMessageConverter<Channel>

org.springframework.http.converter.feed.RssChannelHttpMessageConverter

public RssChannelHttpMessageConverter RssChannelHttpMessageConverter()

{
    super(MediaType.APPLICATION_RSS_XML);
}
org.springframework.http.converter.feed.RssChannelHttpMessageConverter

@Override protected boolean supports(Class<?> clazz)

{
    return Channel.class.isAssignableFrom(clazz);
}


AbstractJackson2HttpMessageConverter
extends AbstractGenericHttpMessageConverter<Object>

org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter

protected AbstractJackson2HttpMessageConverter AbstractJackson2HttpMessageConverter(ObjectMapper objectMapper)

{
    this.objectMapper = objectMapper;
    DefaultPrettyPrinter prettyPrinter = new DefaultPrettyPrinter();
    prettyPrinter.indentObjectsWith(new DefaultIndenter("  ", "\ndata:"));
    this.ssePrettyPrinter = prettyPrinter;
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter

protected AbstractJackson2HttpMessageConverter AbstractJackson2HttpMessageConverter(ObjectMapper objectMapper, MediaType supportedMediaType)

{
    this(objectMapper);
    setSupportedMediaTypes(Collections.singletonList(supportedMediaType));
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter

protected AbstractJackson2HttpMessageConverter AbstractJackson2HttpMessageConverter(ObjectMapper objectMapper, MediaType... supportedMediaTypes)

{
    this(objectMapper);
    setSupportedMediaTypes(Arrays.asList(supportedMediaTypes));
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter

@Nullable @Deprecated public static final Charset DEFAULT_CHARSET

org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter

@Override public boolean canRead(Class<?> clazz, @Nullable MediaType mediaType)

{
    return canRead(clazz, null, mediaType);
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter

@Override public boolean canRead(Type type, @Nullable Class<?> contextClass, @Nullable MediaType mediaType)

{
    if (!canRead(mediaType)) {
        return false;
    } 
    JavaType javaType = getJavaType(type, contextClass);
    AtomicReference<Throwable> causeRef = new AtomicReference<>();
    if (this.objectMapper.canDeserialize(javaType, causeRef)) {
        return true;
    } 
    logWarningIfNecessary(javaType, causeRef.get());
    return false;
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter

@Override public boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType)

{
    if (!canWrite(mediaType)) {
        return false;
    } 
    AtomicReference<Throwable> causeRef = new AtomicReference<>();
    if (this.objectMapper.canSerialize(clazz, causeRef)) {
        return true;
    } 
    logWarningIfNecessary(clazz, causeRef.get());
    return false;
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter

@Override protected Long getContentLength(Object object, @Nullable MediaType contentType)

{
    if (object instanceof MappingJacksonValue) {
        object = ((MappingJacksonValue)object).getValue();
    } 
    return super.getContentLength(object, contentType);
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter

@Override @Nullable protected MediaType getDefaultContentType(Object object)

{
    if (object instanceof MappingJacksonValue) {
        object = ((MappingJacksonValue)object).getValue();
    } 
    return super.getDefaultContentType(object);
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter

protected JavaType getJavaType(Type type, @Nullable Class<?> contextClass)

{
    TypeFactory typeFactory = this.objectMapper.getTypeFactory();
    return typeFactory.constructType(GenericTypeResolver.resolveType(type, contextClass));
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter

protected JsonEncoding getJsonEncoding(@Nullable MediaType contentType)

{
    if (contentType != null && contentType.getCharset() != null) {
        Charset charset = contentType.getCharset();
        for (JsonEncoding encoding: JsonEncoding.values()) {
            if (charset.name().equals(encoding.getJavaName())) {
                return encoding;
            } 
        }
    } 
    return JsonEncoding.UTF8;
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter

public ObjectMapper getObjectMapper()

{
    return this.objectMapper;
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter

protected void logWarningIfNecessary(Type type, @Nullable Throwable cause)

{
    if (cause == null) {
        return ;
    } 
    boolean debugLevel = (cause instanceof JsonMappingException && cause.getMessage().startsWith("Cannot find"));
    if (debugLevel ? logger.isDebugEnabled() : logger.isWarnEnabled()) {
        String msg = "Failed to evaluate Jackson " + (type instanceof JavaType ? "de" : "") + "serialization for type [" + type + "]";
        if (debugLevel) {
            logger.debug(msg, cause);
        } else if (logger.isDebugEnabled()) {
            logger.warn(msg, cause);
        } else {
            logger.warn(msg + ": " + cause);
        }
    } 
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter

protected ObjectMapper objectMapper

org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter

@Override public Object read(Type type, @Nullable Class<?> contextClass, HttpInputMessage inputMessage)

{
    JavaType javaType = getJavaType(type, contextClass);
    return readJavaType(javaType, inputMessage);
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter

@Override protected Object readInternal(Class<?> clazz, HttpInputMessage inputMessage)

{
    JavaType javaType = getJavaType(clazz, null);
    return readJavaType(javaType, inputMessage);
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter

public void setObjectMapper(ObjectMapper objectMapper)

{
    Assert.notNull(objectMapper, "ObjectMapper must not be null");
    this.objectMapper = objectMapper;
    configurePrettyPrint();
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter

public void setPrettyPrint(boolean prettyPrint)

{
    this.prettyPrint = prettyPrint;
    configurePrettyPrint();
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter

@Override protected void writeInternal(Object object, @Nullable Type type, HttpOutputMessage outputMessage)

{
    MediaType contentType = outputMessage.getHeaders().getContentType();
    JsonEncoding encoding = getJsonEncoding(contentType);
    JsonGenerator generator = this.objectMapper.getFactory().createGenerator(outputMessage.getBody(), encoding);
    try {
        writePrefix(generator, object);
        Object value = object;
        Class<?> serializationView = null;
        FilterProvider filters = null;
        JavaType javaType = null;
        if (object instanceof MappingJacksonValue) {
            MappingJacksonValue container = (MappingJacksonValue)object;
            value = container.getValue();
            serializationView = container.getSerializationView();
            filters = container.getFilters();
        } 
        if (type != null && TypeUtils.isAssignable(type, value.getClass())) {
            javaType = getJavaType(type, null);
        } 
        ObjectWriter objectWriter = (serializationView != null ? this.objectMapper.writerWithView(serializationView) : this.objectMapper.writer());
        if (filters != null) {
            objectWriter = objectWriter.with(filters);
        } 
        if (javaType != null && javaType.isContainerType()) {
            objectWriter = objectWriter.forType(javaType);
        } 
        SerializationConfig config = objectWriter.getConfig();
        if (contentType != null && contentType.isCompatibleWith(MediaType.TEXT_EVENT_STREAM) && config.isEnabled(SerializationFeature.INDENT_OUTPUT)) {
            objectWriter = objectWriter.with(this.ssePrettyPrinter);
        } 
        objectWriter.writeValue(generator, value);
        writeSuffix(generator, object);
        generator.flush();
    } catch (InvalidDefinitionException ex) {
        throw new HttpMessageConversionException("Type definition error: " + ex.getType(), ex);
    } catch (JsonProcessingException ex) {
        throw new HttpMessageNotWritableException("Could not write JSON: " + ex.getOriginalMessage(), ex);
    }
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter

protected void writePrefix(JsonGenerator generator, Object object)

{
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter

protected void writeSuffix(JsonGenerator generator, Object object)

{
}

AbstractJsonHttpMessageConverter
extends AbstractGenericHttpMessageConverter<Object>

org.springframework.http.converter.json.AbstractJsonHttpMessageConverter

public AbstractJsonHttpMessageConverter AbstractJsonHttpMessageConverter()

{
    super(MediaType.APPLICATION_JSON, new MediaType("application", "*+json"));
    setDefaultCharset(DEFAULT_CHARSET);
}
org.springframework.http.converter.json.AbstractJsonHttpMessageConverter

public static final Charset DEFAULT_CHARSET

org.springframework.http.converter.json.AbstractJsonHttpMessageConverter

@Override public final Object read(Type type, @Nullable Class<?> contextClass, HttpInputMessage inputMessage)

{
    return readResolved(GenericTypeResolver.resolveType(type, contextClass), inputMessage);
}
org.springframework.http.converter.json.AbstractJsonHttpMessageConverter

@Override protected final Object readInternal(Class<?> clazz, HttpInputMessage inputMessage)

{
    return readResolved(clazz, inputMessage);
}
org.springframework.http.converter.json.AbstractJsonHttpMessageConverter

protected abstract Object readInternal(Type resolvedType, Reader reader)

org.springframework.http.converter.json.AbstractJsonHttpMessageConverter

public void setJsonPrefix(String jsonPrefix)

{
    this.jsonPrefix = jsonPrefix;
}
org.springframework.http.converter.json.AbstractJsonHttpMessageConverter

public void setPrefixJson(boolean prefixJson)

{
    this.jsonPrefix = (prefixJson ? ")]}', " : null);
}
org.springframework.http.converter.json.AbstractJsonHttpMessageConverter

@Override protected final void writeInternal(Object o, @Nullable Type type, HttpOutputMessage outputMessage)

{
    Writer writer = getWriter(outputMessage);
    if (this.jsonPrefix != null) {
        writer.append(this.jsonPrefix);
    } 
    try {
        writeInternal(o, type, writer);
    } catch (Exception ex) {
        throw new HttpMessageNotWritableException("Could not write JSON: " + ex.getMessage(), ex);
    }
    writer.flush();
}
org.springframework.http.converter.json.AbstractJsonHttpMessageConverter

protected abstract void writeInternal(Object o, @Nullable Type type, Writer writer)


GsonBuilderUtils

org.springframework.http.converter.json.GsonBuilderUtils

public static GsonBuilder gsonBuilderWithBase64EncodedByteArrays()

{
    GsonBuilder builder = new GsonBuilder();
    builder.registerTypeHierarchyAdapter(byte[].class, new Base64TypeAdapter());
    return builder;
}

GsonFactoryBean
implements FactoryBean<Gson>, InitializingBean

org.springframework.http.converter.json.GsonFactoryBean

@Override public void afterPropertiesSet()

{
    GsonBuilder builder = (this.base64EncodeByteArrays ? GsonBuilderUtils.gsonBuilderWithBase64EncodedByteArrays() : new GsonBuilder());
    if (this.serializeNulls) {
        builder.serializeNulls();
    } 
    if (this.prettyPrinting) {
        builder.setPrettyPrinting();
    } 
    if (this.disableHtmlEscaping) {
        builder.disableHtmlEscaping();
    } 
    if (this.dateFormatPattern != null) {
        builder.setDateFormat(this.dateFormatPattern);
    } 
    this.gson = builder.create();
}
org.springframework.http.converter.json.GsonFactoryBean

@Override @Nullable public Gson getObject()

{
    return this.gson;
}
org.springframework.http.converter.json.GsonFactoryBean

@Override public Class<?> getObjectType()

{
    return Gson.class;
}
org.springframework.http.converter.json.GsonFactoryBean

@Override public boolean isSingleton()

{
    return true;
}
org.springframework.http.converter.json.GsonFactoryBean

public void setBase64EncodeByteArrays(boolean base64EncodeByteArrays)

{
    this.base64EncodeByteArrays = base64EncodeByteArrays;
}
org.springframework.http.converter.json.GsonFactoryBean

public void setDateFormatPattern(String dateFormatPattern)

{
    this.dateFormatPattern = dateFormatPattern;
}
org.springframework.http.converter.json.GsonFactoryBean

public void setDisableHtmlEscaping(boolean disableHtmlEscaping)

{
    this.disableHtmlEscaping = disableHtmlEscaping;
}
org.springframework.http.converter.json.GsonFactoryBean

public void setPrettyPrinting(boolean prettyPrinting)

{
    this.prettyPrinting = prettyPrinting;
}
org.springframework.http.converter.json.GsonFactoryBean

public void setSerializeNulls(boolean serializeNulls)

{
    this.serializeNulls = serializeNulls;
}

GsonHttpMessageConverter
extends AbstractJsonHttpMessageConverter

org.springframework.http.converter.json.GsonHttpMessageConverter

public GsonHttpMessageConverter GsonHttpMessageConverter()

{
    this.gson = new Gson();
}
org.springframework.http.converter.json.GsonHttpMessageConverter

public GsonHttpMessageConverter GsonHttpMessageConverter(Gson gson)

{
    Assert.notNull(gson, "A Gson instance is required");
    this.gson = gson;
}
org.springframework.http.converter.json.GsonHttpMessageConverter

public Gson getGson()

{
    return this.gson;
}
org.springframework.http.converter.json.GsonHttpMessageConverter

@Override protected Object readInternal(Type resolvedType, Reader reader)

{
    return getGson().fromJson(reader, resolvedType);
}
org.springframework.http.converter.json.GsonHttpMessageConverter

public void setGson(Gson gson)

{
    Assert.notNull(gson, "A Gson instance is required");
    this.gson = gson;
}
org.springframework.http.converter.json.GsonHttpMessageConverter

@Override protected void writeInternal(Object o, @Nullable Type type, Writer writer)

{
    if (type instanceof ParameterizedType) {
        getGson().toJson(o, type, writer);
    } else {
        getGson().toJson(o, writer);
    }
}

Jackson2ObjectMapperBuilder

org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder annotationIntrospector(AnnotationIntrospector annotationIntrospector)

{
    this.annotationIntrospector = annotationIntrospector;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder applicationContext(ApplicationContext applicationContext)

{
    this.applicationContext = applicationContext;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder autoDetectFields(boolean autoDetectFields)

{
    this.features.put(MapperFeature.AUTO_DETECT_FIELDS, autoDetectFields);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public static Jackson2ObjectMapperBuilder cbor()

{
    return new Jackson2ObjectMapperBuilder().factory(new CborFactoryInitializer().create());
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public void configure(ObjectMapper objectMapper)

{
    Assert.notNull(objectMapper, "ObjectMapper must not be null");
    MultiValueMap<Object, Module> modulesToRegister = new LinkedMultiValueMap<>();
    if (this.findModulesViaServiceLoader) {
        ObjectMapper.findModules(this.moduleClassLoader).forEach(module -> registerModule(module, modulesToRegister));
    } else if (this.findWellKnownModules) {
        registerWellKnownModulesIfAvailable(modulesToRegister);
    } 
    if (this.modules != null) {
        this.modules.forEach(module -> registerModule(module, modulesToRegister));
    } 
    if (this.moduleClasses != null) {
        for (Class<? extends Module> moduleClass: this.moduleClasses) {
            registerModule(BeanUtils.instantiateClass(moduleClass), modulesToRegister);
        }
    } 
    List<Module> modules = new ArrayList<>();
    for (List<Module> nestedModules: modulesToRegister.values()) {
        modules.addAll(nestedModules);
    }
    objectMapper.registerModules(modules);
    if (this.dateFormat != null) {
        objectMapper.setDateFormat(this.dateFormat);
    } 
    if (this.locale != null) {
        objectMapper.setLocale(this.locale);
    } 
    if (this.timeZone != null) {
        objectMapper.setTimeZone(this.timeZone);
    } 
    if (this.annotationIntrospector != null) {
        objectMapper.setAnnotationIntrospector(this.annotationIntrospector);
    } 
    if (this.propertyNamingStrategy != null) {
        objectMapper.setPropertyNamingStrategy(this.propertyNamingStrategy);
    } 
    if (this.defaultTyping != null) {
        objectMapper.setDefaultTyping(this.defaultTyping);
    } 
    if (this.serializationInclusion != null) {
        objectMapper.setSerializationInclusion(this.serializationInclusion);
    } 
    if (this.filters != null) {
        objectMapper.setFilterProvider(this.filters);
    } 
    this.mixIns.forEach(objectMapper::addMixIn);
    if (!this.serializers.isEmpty() || !this.deserializers.isEmpty()) {
        SimpleModule module = new SimpleModule();
        addSerializers(module);
        addDeserializers(module);
        objectMapper.registerModule(module);
    } 
    this.visibilities.forEach(objectMapper::setVisibility);
    customizeDefaultFeatures(objectMapper);
    this.features.forEach((feature, enabled) -> configureFeature(objectMapper, feature, enabled));
    if (this.handlerInstantiator != null) {
        objectMapper.setHandlerInstantiator(this.handlerInstantiator);
    } else if (this.applicationContext != null) {
        objectMapper.setHandlerInstantiator(new SpringHandlerInstantiator(this.applicationContext.getAutowireCapableBeanFactory()));
    } 
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder createXmlMapper(boolean createXmlMapper)

{
    this.createXmlMapper = createXmlMapper;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder dateFormat(DateFormat dateFormat)

{
    this.dateFormat = dateFormat;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder defaultTyping(TypeResolverBuilder<?> typeResolverBuilder)

{
    this.defaultTyping = typeResolverBuilder;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder defaultUseWrapper(boolean defaultUseWrapper)

{
    this.defaultUseWrapper = defaultUseWrapper;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder defaultViewInclusion(boolean defaultViewInclusion)

{
    this.features.put(MapperFeature.DEFAULT_VIEW_INCLUSION, defaultViewInclusion);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder deserializerByType(Class<?> type, JsonDeserializer<?> deserializer)

{
    this.deserializers.put(type, deserializer);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder deserializers(JsonDeserializer<?>... deserializers)

{
    for (JsonDeserializer<?> deserializer: deserializers) {
        Class<?> handledType = deserializer.handledType();
        if (handledType == null || handledType == Object.class) {
            throw new IllegalArgumentException("Unknown handled type in " + deserializer.getClass().getName());
        } 
        this.deserializers.put(deserializer.handledType(), deserializer);
    }
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder deserializersByType(Map<Class<?>, JsonDeserializer<?>> deserializers)

{
    this.deserializers.putAll(deserializers);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder factory(JsonFactory factory)

{
    this.factory = factory;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder failOnEmptyBeans(boolean failOnEmptyBeans)

{
    this.features.put(SerializationFeature.FAIL_ON_EMPTY_BEANS, failOnEmptyBeans);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder failOnUnknownProperties(boolean failOnUnknownProperties)

{
    this.features.put(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, failOnUnknownProperties);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder featuresToDisable(Object... featuresToDisable)

{
    for (Object feature: featuresToDisable) {
        this.features.put(feature, Boolean.FALSE);
    }
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder featuresToEnable(Object... featuresToEnable)

{
    for (Object feature: featuresToEnable) {
        this.features.put(feature, Boolean.TRUE);
    }
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder filters(FilterProvider filters)

{
    this.filters = filters;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder findModulesViaServiceLoader(boolean findModules)

{
    this.findModulesViaServiceLoader = findModules;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder handlerInstantiator(HandlerInstantiator handlerInstantiator)

{
    this.handlerInstantiator = handlerInstantiator;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder indentOutput(boolean indentOutput)

{
    this.features.put(SerializationFeature.INDENT_OUTPUT, indentOutput);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public static Jackson2ObjectMapperBuilder json()

{
    return new Jackson2ObjectMapperBuilder();
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

volatile static boolean kotlinWarningLogged

org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder locale(Locale locale)

{
    this.locale = locale;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder locale(String localeString)

{
    this.locale = StringUtils.parseLocale(localeString);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder mixIn(Class<?> target, Class<?> mixinSource)

{
    this.mixIns.put(target, mixinSource);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder mixIns(Map<Class<?>, Class<?>> mixIns)

{
    this.mixIns.putAll(mixIns);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder moduleClassLoader(ClassLoader moduleClassLoader)

{
    this.moduleClassLoader = moduleClassLoader;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder modules(Module... modules)

{
    return modules(Arrays.asList(modules));
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder modules(List<Module> modules)

{
    this.modules = new LinkedList<>(modules);
    this.findModulesViaServiceLoader = false;
    this.findWellKnownModules = false;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder modulesToInstall(Module... modules)

{
    this.modules = Arrays.asList(modules);
    this.findWellKnownModules = true;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

@SuppressWarnings("unchecked") public Jackson2ObjectMapperBuilder modulesToInstall(Class<?>... modules)

{
    this.moduleClasses = modules;
    this.findWellKnownModules = true;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder propertyNamingStrategy(PropertyNamingStrategy propertyNamingStrategy)

{
    this.propertyNamingStrategy = propertyNamingStrategy;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder serializationInclusion(JsonInclude.Include serializationInclusion)

{
    this.serializationInclusion = serializationInclusion;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder serializerByType(Class<?> type, JsonSerializer<?> serializer)

{
    this.serializers.put(type, serializer);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder serializers(JsonSerializer<?>... serializers)

{
    for (JsonSerializer<?> serializer: serializers) {
        Class<?> handledType = serializer.handledType();
        if (handledType == null || handledType == Object.class) {
            throw new IllegalArgumentException("Unknown handled type in " + serializer.getClass().getName());
        } 
        this.serializers.put(serializer.handledType(), serializer);
    }
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder serializersByType(Map<Class<?>, JsonSerializer<?>> serializers)

{
    this.serializers.putAll(serializers);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder simpleDateFormat(String format)

{
    this.dateFormat = new SimpleDateFormat(format);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public static Jackson2ObjectMapperBuilder smile()

{
    return new Jackson2ObjectMapperBuilder().factory(new SmileFactoryInitializer().create());
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder timeZone(TimeZone timeZone)

{
    this.timeZone = timeZone;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder timeZone(String timeZoneString)

{
    this.timeZone = StringUtils.parseTimeZoneString(timeZoneString);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public Jackson2ObjectMapperBuilder visibility(PropertyAccessor accessor, JsonAutoDetect.Visibility visibility)

{
    this.visibilities.put(accessor, visibility);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder

public static Jackson2ObjectMapperBuilder xml()

{
    return new Jackson2ObjectMapperBuilder().createXmlMapper(true);
}

Jackson2ObjectMapperFactoryBean
implements FactoryBean<ObjectMapper>, BeanClassLoaderAware, ApplicationContextAware, InitializingBean

org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

@Override public void afterPropertiesSet()

{
    if (this.objectMapper != null) {
        this.builder.configure(this.objectMapper);
    } else {
        this.objectMapper = this.builder.build();
    }
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

@Override @Nullable public ObjectMapper getObject()

{
    return this.objectMapper;
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

@Override public Class<?> getObjectType()

{
    return (this.objectMapper != null ? this.objectMapper.getClass() : null);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

@Override public boolean isSingleton()

{
    return true;
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setAnnotationIntrospector(AnnotationIntrospector annotationIntrospector)

{
    this.builder.annotationIntrospector(annotationIntrospector);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

@Override public void setApplicationContext(ApplicationContext applicationContext)

{
    this.builder.applicationContext(applicationContext);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setAutoDetectFields(boolean autoDetectFields)

{
    this.builder.autoDetectFields(autoDetectFields);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setAutoDetectGettersSetters(boolean autoDetectGettersSetters)

{
    this.builder.autoDetectGettersSetters(autoDetectGettersSetters);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

@Override public void setBeanClassLoader(ClassLoader beanClassLoader)

{
    this.builder.moduleClassLoader(beanClassLoader);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setCreateXmlMapper(boolean createXmlMapper)

{
    this.builder.createXmlMapper(createXmlMapper);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setDateFormat(DateFormat dateFormat)

{
    this.builder.dateFormat(dateFormat);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setDefaultTyping(TypeResolverBuilder<?> typeResolverBuilder)

{
    this.builder.defaultTyping(typeResolverBuilder);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setDefaultUseWrapper(boolean defaultUseWrapper)

{
    this.builder.defaultUseWrapper(defaultUseWrapper);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setDefaultViewInclusion(boolean defaultViewInclusion)

{
    this.builder.defaultViewInclusion(defaultViewInclusion);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setDeserializers(JsonDeserializer<?>... deserializers)

{
    this.builder.deserializers(deserializers);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setDeserializersByType(Map<Class<?>, JsonDeserializer<?>> deserializers)

{
    this.builder.deserializersByType(deserializers);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setFactory(JsonFactory factory)

{
    this.builder.factory(factory);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setFailOnEmptyBeans(boolean failOnEmptyBeans)

{
    this.builder.failOnEmptyBeans(failOnEmptyBeans);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setFailOnUnknownProperties(boolean failOnUnknownProperties)

{
    this.builder.failOnUnknownProperties(failOnUnknownProperties);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setFeaturesToDisable(Object... featuresToDisable)

{
    this.builder.featuresToDisable(featuresToDisable);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setFeaturesToEnable(Object... featuresToEnable)

{
    this.builder.featuresToEnable(featuresToEnable);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setFilters(FilterProvider filters)

{
    this.builder.filters(filters);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setFindModulesViaServiceLoader(boolean findModules)

{
    this.builder.findModulesViaServiceLoader(findModules);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setHandlerInstantiator(HandlerInstantiator handlerInstantiator)

{
    this.builder.handlerInstantiator(handlerInstantiator);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setIndentOutput(boolean indentOutput)

{
    this.builder.indentOutput(indentOutput);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setLocale(Locale locale)

{
    this.builder.locale(locale);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setMixIns(Map<Class<?>, Class<?>> mixIns)

{
    this.builder.mixIns(mixIns);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setModules(List<Module> modules)

{
    this.builder.modules(modules);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

@SuppressWarnings("unchecked") public void setModulesToInstall(Class<?>... modules)

{
    this.builder.modulesToInstall(modules);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setObjectMapper(ObjectMapper objectMapper)

{
    this.objectMapper = objectMapper;
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setPropertyNamingStrategy(PropertyNamingStrategy propertyNamingStrategy)

{
    this.builder.propertyNamingStrategy(propertyNamingStrategy);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setSerializationInclusion(JsonInclude.Include serializationInclusion)

{
    this.builder.serializationInclusion(serializationInclusion);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setSerializers(JsonSerializer<?>... serializers)

{
    this.builder.serializers(serializers);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setSerializersByType(Map<Class<?>, JsonSerializer<?>> serializers)

{
    this.builder.serializersByType(serializers);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setSimpleDateFormat(String format)

{
    this.builder.simpleDateFormat(format);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean

public void setTimeZone(TimeZone timeZone)

{
    this.builder.timeZone(timeZone);
}

JsonbHttpMessageConverter
extends AbstractJsonHttpMessageConverter

org.springframework.http.converter.json.JsonbHttpMessageConverter

public JsonbHttpMessageConverter JsonbHttpMessageConverter()

{
    this(JsonbBuilder.create());
}
org.springframework.http.converter.json.JsonbHttpMessageConverter

public JsonbHttpMessageConverter JsonbHttpMessageConverter(JsonbConfig config)

{
    this.jsonb = JsonbBuilder.create(config);
}
org.springframework.http.converter.json.JsonbHttpMessageConverter

public JsonbHttpMessageConverter JsonbHttpMessageConverter(Jsonb jsonb)

{
    Assert.notNull(jsonb, "A Jsonb instance is required");
    this.jsonb = jsonb;
}
org.springframework.http.converter.json.JsonbHttpMessageConverter

public Jsonb getJsonb()

{
    return this.jsonb;
}
org.springframework.http.converter.json.JsonbHttpMessageConverter

@Override protected Object readInternal(Type resolvedType, Reader reader)

{
    return getJsonb().fromJson(reader, resolvedType);
}
org.springframework.http.converter.json.JsonbHttpMessageConverter

public void setJsonb(Jsonb jsonb)

{
    Assert.notNull(jsonb, "A Jsonb instance is required");
    this.jsonb = jsonb;
}
org.springframework.http.converter.json.JsonbHttpMessageConverter

@Override protected void writeInternal(Object o, @Nullable Type type, Writer writer)

{
    if (type instanceof ParameterizedType) {
        getJsonb().toJson(o, type, writer);
    } else {
        getJsonb().toJson(o, writer);
    }
}

MappingJackson2HttpMessageConverter
extends AbstractJackson2HttpMessageConverter

org.springframework.http.converter.json.MappingJackson2HttpMessageConverter

public MappingJackson2HttpMessageConverter MappingJackson2HttpMessageConverter()

{
    this(Jackson2ObjectMapperBuilder.json().build());
}
org.springframework.http.converter.json.MappingJackson2HttpMessageConverter

public MappingJackson2HttpMessageConverter MappingJackson2HttpMessageConverter(ObjectMapper objectMapper)

{
    super(objectMapper, MediaType.APPLICATION_JSON, new MediaType("application", "*+json"));
}
org.springframework.http.converter.json.MappingJackson2HttpMessageConverter

public void setJsonPrefix(String jsonPrefix)

{
    this.jsonPrefix = jsonPrefix;
}
org.springframework.http.converter.json.MappingJackson2HttpMessageConverter

public void setPrefixJson(boolean prefixJson)

{
    this.jsonPrefix = (prefixJson ? ")]}', " : null);
}
org.springframework.http.converter.json.MappingJackson2HttpMessageConverter

@Override protected void writePrefix(JsonGenerator generator, Object object)

{
    if (this.jsonPrefix != null) {
        generator.writeRaw(this.jsonPrefix);
    } 
}

MappingJacksonInputMessage
implements HttpInputMessage

org.springframework.http.converter.json.MappingJacksonInputMessage

public MappingJacksonInputMessage MappingJacksonInputMessage(InputStream body, HttpHeaders headers)

{
    this.body = body;
    this.headers = headers;
}
org.springframework.http.converter.json.MappingJacksonInputMessage

public MappingJacksonInputMessage MappingJacksonInputMessage(InputStream body, HttpHeaders headers, Class<?> deserializationView)

{
    this(body, headers);
    this.deserializationView = deserializationView;
}
org.springframework.http.converter.json.MappingJacksonInputMessage

@Override public InputStream getBody()

{
    return this.body;
}
org.springframework.http.converter.json.MappingJacksonInputMessage

@Nullable public Class<?> getDeserializationView()

{
    return this.deserializationView;
}
org.springframework.http.converter.json.MappingJacksonInputMessage

@Override public HttpHeaders getHeaders()

{
    return this.headers;
}
org.springframework.http.converter.json.MappingJacksonInputMessage

public void setDeserializationView(@Nullable Class<?> deserializationView)

{
    this.deserializationView = deserializationView;
}

MappingJacksonValue

org.springframework.http.converter.json.MappingJacksonValue

public MappingJacksonValue MappingJacksonValue(Object value)

{
    this.value = value;
}
org.springframework.http.converter.json.MappingJacksonValue

@Nullable public FilterProvider getFilters()

{
    return this.filters;
}
org.springframework.http.converter.json.MappingJacksonValue

@Nullable public Class<?> getSerializationView()

{
    return this.serializationView;
}
org.springframework.http.converter.json.MappingJacksonValue

public Object getValue()

{
    return this.value;
}
org.springframework.http.converter.json.MappingJacksonValue

public void setFilters(@Nullable FilterProvider filters)

{
    this.filters = filters;
}
org.springframework.http.converter.json.MappingJacksonValue

public void setSerializationView(@Nullable Class<?> serializationView)

{
    this.serializationView = serializationView;
}
org.springframework.http.converter.json.MappingJacksonValue

public void setValue(Object value)

{
    this.value = value;
}

SpringHandlerInstantiator
extends HandlerInstantiator

org.springframework.http.converter.json.SpringHandlerInstantiator

public SpringHandlerInstantiator SpringHandlerInstantiator(AutowireCapableBeanFactory beanFactory)

{
    Assert.notNull(beanFactory, "BeanFactory must not be null");
    this.beanFactory = beanFactory;
}
org.springframework.http.converter.json.SpringHandlerInstantiator

@Override public Converter<?, ?> converterInstance(MapperConfig<?> config, Annotated annotated, Class<?> implClass)

{
    return (Converter<?, ?>)this.beanFactory.createBean(implClass);
}
org.springframework.http.converter.json.SpringHandlerInstantiator

@Override public JsonDeserializer<?> deserializerInstance(DeserializationConfig config, Annotated annotated, Class<?> implClass)

{
    return (JsonDeserializer<?>)this.beanFactory.createBean(implClass);
}
org.springframework.http.converter.json.SpringHandlerInstantiator

@Override public KeyDeserializer keyDeserializerInstance(DeserializationConfig config, Annotated annotated, Class<?> implClass)

{
    return (KeyDeserializer)this.beanFactory.createBean(implClass);
}
org.springframework.http.converter.json.SpringHandlerInstantiator

@Override public PropertyNamingStrategy namingStrategyInstance(MapperConfig<?> config, Annotated annotated, Class<?> implClass)

{
    return (PropertyNamingStrategy)this.beanFactory.createBean(implClass);
}
org.springframework.http.converter.json.SpringHandlerInstantiator

@Override public ObjectIdGenerator<?> objectIdGeneratorInstance(MapperConfig<?> config, Annotated annotated, Class<?> implClass)

{
    return (ObjectIdGenerator<?>)this.beanFactory.createBean(implClass);
}
org.springframework.http.converter.json.SpringHandlerInstantiator

@Override public ObjectIdResolver resolverIdGeneratorInstance(MapperConfig<?> config, Annotated annotated, Class<?> implClass)

{
    return (ObjectIdResolver)this.beanFactory.createBean(implClass);
}
org.springframework.http.converter.json.SpringHandlerInstantiator

@Override public JsonSerializer<?> serializerInstance(SerializationConfig config, Annotated annotated, Class<?> implClass)

{
    return (JsonSerializer<?>)this.beanFactory.createBean(implClass);
}
org.springframework.http.converter.json.SpringHandlerInstantiator

@Override public TypeIdResolver typeIdResolverInstance(MapperConfig<?> config, Annotated annotated, Class<?> implClass)

{
    return (TypeIdResolver)this.beanFactory.createBean(implClass);
}
org.springframework.http.converter.json.SpringHandlerInstantiator

@Override public TypeResolverBuilder<?> typeResolverBuilderInstance(MapperConfig<?> config, Annotated annotated, Class<?> implClass)

{
    return (TypeResolverBuilder<?>)this.beanFactory.createBean(implClass);
}
org.springframework.http.converter.json.SpringHandlerInstantiator

@Override public ValueInstantiator valueInstantiatorInstance(MapperConfig<?> config, Annotated annotated, Class<?> implClass)

{
    return (ValueInstantiator)this.beanFactory.createBean(implClass);
}
org.springframework.http.converter.json.SpringHandlerInstantiator

@Override public VirtualBeanPropertyWriter virtualPropertyWriterInstance(MapperConfig<?> config, Class<?> implClass)

{
    return (VirtualBeanPropertyWriter)this.beanFactory.createBean(implClass);
}



ExtensionRegistryInitializer

ProtobufHttpMessageConverter
extends AbstractHttpMessageConverter<Message>

org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter

public static final Charset DEFAULT_CHARSET

org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter

public static final MediaType PROTOBUF

org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter

public ProtobufHttpMessageConverter ProtobufHttpMessageConverter()

{
    this(null, null);
}
org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter

@Deprecated public ProtobufHttpMessageConverter ProtobufHttpMessageConverter(@Nullable ExtensionRegistryInitializer registryInitializer)

{
    this(null, null);
    if (registryInitializer != null) {
        registryInitializer.initializeExtensionRegistry(this.extensionRegistry);
    } 
}
org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter

public ProtobufHttpMessageConverter ProtobufHttpMessageConverter(ExtensionRegistry extensionRegistry)

{
    this(null, extensionRegistry);
}
org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter

public static final String X_PROTOBUF_MESSAGE_HEADER

org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter

public static final String X_PROTOBUF_SCHEMA_HEADER

org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter

@Override protected boolean canWrite(@Nullable MediaType mediaType)

{
    return (super.canWrite(mediaType) || (this.protobufFormatSupport != null && this.protobufFormatSupport.supportsWriteOnly(mediaType)));
}
org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter

@Override protected MediaType getDefaultContentType(Message message)

{
    return PROTOBUF;
}
org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter

@Override protected Message readInternal(Class<?> clazz, HttpInputMessage inputMessage)

{
    MediaType contentType = inputMessage.getHeaders().getContentType();
    if (contentType == null) {
        contentType = PROTOBUF;
    } 
    Charset charset = contentType.getCharset();
    if (charset == null) {
        charset = DEFAULT_CHARSET;
    } 
    Message.Builder builder = getMessageBuilder(clazz);
    if (PROTOBUF.isCompatibleWith(contentType)) {
        builder.mergeFrom(inputMessage.getBody(), this.extensionRegistry);
    } else if (TEXT_PLAIN.isCompatibleWith(contentType)) {
        InputStreamReader reader = new InputStreamReader(inputMessage.getBody(), charset);
        TextFormat.merge(reader, this.extensionRegistry, builder);
    } else if (this.protobufFormatSupport != null) {
        this.protobufFormatSupport.merge(inputMessage.getBody(), charset, contentType, this.extensionRegistry, builder);
    } 
    return builder.build();
}
org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter

@Override protected boolean supports(Class<?> clazz)

{
    return Message.class.isAssignableFrom(clazz);
}

ProtobufJsonFormatHttpMessageConverter
extends ProtobufHttpMessageConverter

org.springframework.http.converter.protobuf.ProtobufJsonFormatHttpMessageConverter

public ProtobufJsonFormatHttpMessageConverter ProtobufJsonFormatHttpMessageConverter()

{
    this(null, null, (ExtensionRegistry)null);
}
org.springframework.http.converter.protobuf.ProtobufJsonFormatHttpMessageConverter

public ProtobufJsonFormatHttpMessageConverter ProtobufJsonFormatHttpMessageConverter(@Nullable JsonFormat.Parser parser, @Nullable JsonFormat.Printer printer)

{
    this(parser, printer, (ExtensionRegistry)null);
}
org.springframework.http.converter.protobuf.ProtobufJsonFormatHttpMessageConverter

public ProtobufJsonFormatHttpMessageConverter ProtobufJsonFormatHttpMessageConverter(@Nullable JsonFormat.Parser parser, @Nullable JsonFormat.Printer printer, @Nullable ExtensionRegistry extensionRegistry)

{
    super(new ProtobufJavaUtilSupport(parser, printer), extensionRegistry);
}
org.springframework.http.converter.protobuf.ProtobufJsonFormatHttpMessageConverter

@Deprecated public ProtobufJsonFormatHttpMessageConverter ProtobufJsonFormatHttpMessageConverter(@Nullable JsonFormat.Parser parser, @Nullable JsonFormat.Printer printer, @Nullable ExtensionRegistryInitializer registryInitializer)

{
    super(new ProtobufJavaUtilSupport(parser, printer), null);
    if (registryInitializer != null) {
        registryInitializer.initializeExtensionRegistry(this.extensionRegistry);
    } 
}


MappingJackson2SmileHttpMessageConverter
extends AbstractJackson2HttpMessageConverter

org.springframework.http.converter.smile.MappingJackson2SmileHttpMessageConverter

public MappingJackson2SmileHttpMessageConverter MappingJackson2SmileHttpMessageConverter()

{
    this(Jackson2ObjectMapperBuilder.smile().build());
}
org.springframework.http.converter.smile.MappingJackson2SmileHttpMessageConverter

public MappingJackson2SmileHttpMessageConverter MappingJackson2SmileHttpMessageConverter(ObjectMapper objectMapper)

{
    super(objectMapper, new MediaType("application", "x-jackson-smile"));
    Assert.isInstanceOf(SmileFactory.class, objectMapper.getFactory(), "SmileFactory required");
}
org.springframework.http.converter.smile.MappingJackson2SmileHttpMessageConverter

@Override public void setObjectMapper(ObjectMapper objectMapper)

{
    Assert.isInstanceOf(SmileFactory.class, objectMapper.getFactory(), "SmileFactory required");
    super.setObjectMapper(objectMapper);
}


AllEncompassingFormHttpMessageConverter
extends FormHttpMessageConverter

org.springframework.http.converter.support.AllEncompassingFormHttpMessageConverter

public AllEncompassingFormHttpMessageConverter AllEncompassingFormHttpMessageConverter()

{
    try {
        addPartConverter(new SourceHttpMessageConverter<>());
    } catch (Error err) {
    }
    if (jaxb2Present && !jackson2XmlPresent) {
        addPartConverter(new Jaxb2RootElementHttpMessageConverter());
    } 
    if (jackson2Present) {
        addPartConverter(new MappingJackson2HttpMessageConverter());
    } else if (gsonPresent) {
        addPartConverter(new GsonHttpMessageConverter());
    } else if (jsonbPresent) {
        addPartConverter(new JsonbHttpMessageConverter());
    } 
    if (jackson2XmlPresent) {
        addPartConverter(new MappingJackson2XmlHttpMessageConverter());
    } 
    if (jackson2SmilePresent) {
        addPartConverter(new MappingJackson2SmileHttpMessageConverter());
    } 
}


AbstractJaxb2HttpMessageConverter<T>
extends AbstractXmlHttpMessageConverter<T>

org.springframework.http.converter.xml.AbstractJaxb2HttpMessageConverter

protected void customizeMarshaller(Marshaller marshaller)

{
}
org.springframework.http.converter.xml.AbstractJaxb2HttpMessageConverter

protected void customizeUnmarshaller(Unmarshaller unmarshaller)

{
}

AbstractXmlHttpMessageConverter<T>
extends AbstractHttpMessageConverter<T>

org.springframework.http.converter.xml.AbstractXmlHttpMessageConverter

protected AbstractXmlHttpMessageConverter AbstractXmlHttpMessageConverter()

{
    super(MediaType.APPLICATION_XML, MediaType.TEXT_XML, new MediaType("application", "*+xml"));
}
org.springframework.http.converter.xml.AbstractXmlHttpMessageConverter

protected abstract T readFromSource(Class<?> clazz, HttpHeaders headers, Source source)

org.springframework.http.converter.xml.AbstractXmlHttpMessageConverter

@Override public final T readInternal(Class<?> clazz, HttpInputMessage inputMessage)

{
    try {
        return readFromSource(clazz, inputMessage.getHeaders(), new StreamSource(inputMessage.getBody()));
    } catch (IOException | HttpMessageConversionException ex) {
        throw ex;
    } catch (Exception ex) {
        throw new HttpMessageNotReadableException("Could not unmarshal to [" + clazz + "]: " + ex.getMessage(), ex, inputMessage);
    }
}
org.springframework.http.converter.xml.AbstractXmlHttpMessageConverter

protected void transform(Source source, Result result)

{
    this.transformerFactory.newTransformer().transform(source, result);
}
org.springframework.http.converter.xml.AbstractXmlHttpMessageConverter

@Override protected final void writeInternal(T t, HttpOutputMessage outputMessage)

{
    try {
        writeToResult(t, outputMessage.getHeaders(), new StreamResult(outputMessage.getBody()));
    } catch (IOException | HttpMessageConversionException ex) {
        throw ex;
    } catch (Exception ex) {
        throw new HttpMessageNotWritableException("Could not marshal [" + t + "]: " + ex.getMessage(), ex);
    }
}
org.springframework.http.converter.xml.AbstractXmlHttpMessageConverter

protected abstract void writeToResult(T t, HttpHeaders headers, Result result)


Jaxb2CollectionHttpMessageConverter<T>
extends AbstractJaxb2HttpMessageConverter<T> implements GenericHttpMessageConverter<T>

org.springframework.http.converter.xml.Jaxb2CollectionHttpMessageConverter

@Override public boolean canRead(Class<?> clazz, @Nullable MediaType mediaType)

{
    return false;
}
org.springframework.http.converter.xml.Jaxb2CollectionHttpMessageConverter

@Override public boolean canRead(Type type, @Nullable Class<?> contextClass, @Nullable MediaType mediaType)

{
    if (!(type instanceof ParameterizedType)) {
        return false;
    } 
    ParameterizedType parameterizedType = (ParameterizedType)type;
    if (!(parameterizedType.getRawType() instanceof Class)) {
        return false;
    } 
    Class<?> rawType = (Class<?>)parameterizedType.getRawType();
    if (!(Collection.class.isAssignableFrom(rawType))) {
        return false;
    } 
    if (parameterizedType.getActualTypeArguments().length != 1) {
        return false;
    } 
    Type typeArgument = parameterizedType.getActualTypeArguments()[0];
    if (!(typeArgument instanceof Class)) {
        return false;
    } 
    Class<?> typeArgumentClass = (Class<?>)typeArgument;
    return (typeArgumentClass.isAnnotationPresent(XmlRootElement.class) || typeArgumentClass.isAnnotationPresent(XmlType.class)) && canRead(mediaType);
}
org.springframework.http.converter.xml.Jaxb2CollectionHttpMessageConverter

@Override public boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType)

{
    return false;
}
org.springframework.http.converter.xml.Jaxb2CollectionHttpMessageConverter

@Override public boolean canWrite(@Nullable Type type, @Nullable Class<?> clazz, @Nullable MediaType mediaType)

{
    return false;
}
org.springframework.http.converter.xml.Jaxb2CollectionHttpMessageConverter

@SuppressWarnings("unchecked") protected T createCollection(Class<?> collectionClass)

{
    if (!collectionClass.isInterface()) {
        try {
            return (T)ReflectionUtils.accessibleConstructor(collectionClass).newInstance();
        } catch (Throwable ex) {
            throw new IllegalArgumentException("Could not instantiate collection class: " + collectionClass.getName(), ex);
        }
    } else if (List.class == collectionClass) {
        return (T)new ArrayList();
    } else if (SortedSet.class == collectionClass) {
        return (T)new TreeSet();
    } else {
        return (T)new LinkedHashSet();
    }
}
org.springframework.http.converter.xml.Jaxb2CollectionHttpMessageConverter

protected XMLInputFactory createXmlInputFactory()

{
    return StaxUtils.createDefensiveInputFactory();
}
org.springframework.http.converter.xml.Jaxb2CollectionHttpMessageConverter

@Override @SuppressWarnings("unchecked") public T read(Type type, @Nullable Class<?> contextClass, HttpInputMessage inputMessage)

{
    ParameterizedType parameterizedType = (ParameterizedType)type;
    T result = createCollection((Class<?>)parameterizedType.getRawType());
    Class<?> elementClass = (Class<?>)parameterizedType.getActualTypeArguments()[0];
    try {
        Unmarshaller unmarshaller = createUnmarshaller(elementClass);
        XMLStreamReader streamReader = this.inputFactory.createXMLStreamReader(inputMessage.getBody());
        int event = moveToFirstChildOfRootElement(streamReader);
        while (event != XMLStreamReader.END_DOCUMENT) {
            if (elementClass.isAnnotationPresent(XmlRootElement.class)) {
                result.add(unmarshaller.unmarshal(streamReader));
            } else if (elementClass.isAnnotationPresent(XmlType.class)) {
                result.add(unmarshaller.unmarshal(streamReader, elementClass).getValue());
            } else {
                throw new HttpMessageNotReadableException("Cannot unmarshal to [" + elementClass + "]", inputMessage);
            }
            event = moveToNextElement(streamReader);
        }
        return result;
    } catch (XMLStreamException ex) {
        throw new HttpMessageNotReadableException("Failed to read XML stream: " + ex.getMessage(), ex, inputMessage);
    } catch (UnmarshalException ex) {
        throw new HttpMessageNotReadableException("Could not unmarshal to [" + elementClass + "]: " + ex.getMessage(), ex, inputMessage);
    } catch (JAXBException ex) {
        throw new HttpMessageConversionException("Invalid JAXB setup: " + ex.getMessage(), ex);
    }
}
org.springframework.http.converter.xml.Jaxb2CollectionHttpMessageConverter

@Override protected T readFromSource(Class<?> clazz, HttpHeaders headers, Source source)

{
    throw new UnsupportedOperationException();
}
org.springframework.http.converter.xml.Jaxb2CollectionHttpMessageConverter

@Override protected boolean supports(Class<?> clazz)

{
    throw new UnsupportedOperationException();
}
org.springframework.http.converter.xml.Jaxb2CollectionHttpMessageConverter

@Override public void write(T t, @Nullable Type type, @Nullable MediaType contentType, HttpOutputMessage outputMessage)

{
    throw new UnsupportedOperationException();
}
org.springframework.http.converter.xml.Jaxb2CollectionHttpMessageConverter

@Override protected void writeToResult(T t, HttpHeaders headers, Result result)

{
    throw new UnsupportedOperationException();
}

Jaxb2RootElementHttpMessageConverter
extends AbstractJaxb2HttpMessageConverter<Object>

org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter

@Override public boolean canRead(Class<?> clazz, @Nullable MediaType mediaType)

{
    return (clazz.isAnnotationPresent(XmlRootElement.class) || clazz.isAnnotationPresent(XmlType.class)) && canRead(mediaType);
}
org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter

@Override public boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType)

{
    return (AnnotationUtils.findAnnotation(clazz, XmlRootElement.class) != null && canWrite(mediaType));
}
org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter

public boolean isProcessExternalEntities()

{
    return this.processExternalEntities;
}
org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter

public boolean isSupportDtd()

{
    return this.supportDtd;
}
org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter

public void setProcessExternalEntities(boolean processExternalEntities)

{
    this.processExternalEntities = processExternalEntities;
    if (processExternalEntities) {
        this.supportDtd = true;
    } 
}
org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter

public void setSupportDtd(boolean supportDtd)

{
    this.supportDtd = supportDtd;
}
org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter

@Override protected boolean supports(Class<?> clazz)

{
    throw new UnsupportedOperationException();
}
org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter

@Override protected void writeToResult(Object o, HttpHeaders headers, Result result)

{
    try {
        Class<?> clazz = ClassUtils.getUserClass(o);
        Marshaller marshaller = createMarshaller(clazz);
        setCharset(headers.getContentType(), marshaller);
        marshaller.marshal(o, result);
    } catch (MarshalException ex) {
        throw ex;
    } catch (JAXBException ex) {
        throw new HttpMessageConversionException("Invalid JAXB setup: " + ex.getMessage(), ex);
    }
}

MappingJackson2XmlHttpMessageConverter
extends AbstractJackson2HttpMessageConverter

org.springframework.http.converter.xml.MappingJackson2XmlHttpMessageConverter

public MappingJackson2XmlHttpMessageConverter MappingJackson2XmlHttpMessageConverter()

{
    this(Jackson2ObjectMapperBuilder.xml().build());
}
org.springframework.http.converter.xml.MappingJackson2XmlHttpMessageConverter

public MappingJackson2XmlHttpMessageConverter MappingJackson2XmlHttpMessageConverter(ObjectMapper objectMapper)

{
    super(objectMapper, new MediaType("application", "xml", StandardCharsets.UTF_8), new MediaType("text", "xml", StandardCharsets.UTF_8), new MediaType("application", "*+xml", StandardCharsets.UTF_8));
    Assert.isInstanceOf(XmlMapper.class, objectMapper, "XmlMapper required");
}
org.springframework.http.converter.xml.MappingJackson2XmlHttpMessageConverter

@Override public void setObjectMapper(ObjectMapper objectMapper)

{
    Assert.isInstanceOf(XmlMapper.class, objectMapper, "XmlMapper required");
    super.setObjectMapper(objectMapper);
}

MarshallingHttpMessageConverter
extends AbstractXmlHttpMessageConverter<Object>

org.springframework.http.converter.xml.MarshallingHttpMessageConverter

public MarshallingHttpMessageConverter MarshallingHttpMessageConverter()

{
}
org.springframework.http.converter.xml.MarshallingHttpMessageConverter

public MarshallingHttpMessageConverter MarshallingHttpMessageConverter(Marshaller marshaller)

{
    Assert.notNull(marshaller, "Marshaller must not be null");
    this.marshaller = marshaller;
    if (marshaller instanceof Unmarshaller) {
        this.unmarshaller = (Unmarshaller)marshaller;
    } 
}
org.springframework.http.converter.xml.MarshallingHttpMessageConverter

public MarshallingHttpMessageConverter MarshallingHttpMessageConverter(Marshaller marshaller, Unmarshaller unmarshaller)

{
    Assert.notNull(marshaller, "Marshaller must not be null");
    Assert.notNull(unmarshaller, "Unmarshaller must not be null");
    this.marshaller = marshaller;
    this.unmarshaller = unmarshaller;
}
org.springframework.http.converter.xml.MarshallingHttpMessageConverter

@Override public boolean canRead(Class<?> clazz, @Nullable MediaType mediaType)

{
    return (canRead(mediaType) && this.unmarshaller != null && this.unmarshaller.supports(clazz));
}
org.springframework.http.converter.xml.MarshallingHttpMessageConverter

@Override public boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType)

{
    return (canWrite(mediaType) && this.marshaller != null && this.marshaller.supports(clazz));
}
org.springframework.http.converter.xml.MarshallingHttpMessageConverter

@Override protected Object readFromSource(Class<?> clazz, HttpHeaders headers, Source source)

{
    Assert.notNull(this.unmarshaller, "Property 'unmarshaller' is required");
    Object result = this.unmarshaller.unmarshal(source);
    if (!clazz.isInstance(result)) {
        throw new TypeMismatchException(result, clazz);
    } 
    return result;
}
org.springframework.http.converter.xml.MarshallingHttpMessageConverter

public void setMarshaller(Marshaller marshaller)

{
    this.marshaller = marshaller;
}
org.springframework.http.converter.xml.MarshallingHttpMessageConverter

public void setUnmarshaller(Unmarshaller unmarshaller)

{
    this.unmarshaller = unmarshaller;
}
org.springframework.http.converter.xml.MarshallingHttpMessageConverter

@Override protected boolean supports(Class<?> clazz)

{
    throw new UnsupportedOperationException();
}
org.springframework.http.converter.xml.MarshallingHttpMessageConverter

@Override protected void writeToResult(Object o, HttpHeaders headers, Result result)

{
    Assert.notNull(this.marshaller, "Property 'marshaller' is required");
    this.marshaller.marshal(o, result);
}

SourceHttpMessageConverter<T>
extends AbstractHttpMessageConverter<T>

org.springframework.http.converter.xml.SourceHttpMessageConverter

public SourceHttpMessageConverter SourceHttpMessageConverter()

{
    super(MediaType.APPLICATION_XML, MediaType.TEXT_XML, new MediaType("application", "*+xml"));
}
org.springframework.http.converter.xml.SourceHttpMessageConverter

@Override @Nullable protected Long getContentLength(T t, @Nullable MediaType contentType)

{
    if (t instanceof DOMSource) {
        try {
            CountingOutputStream os = new CountingOutputStream();
            transform(t, new StreamResult(os));
            return os.count;
        } catch (TransformerException ex) {
        }
    } 
    return null;
}
org.springframework.http.converter.xml.SourceHttpMessageConverter

public boolean isProcessExternalEntities()

{
    return this.processExternalEntities;
}
org.springframework.http.converter.xml.SourceHttpMessageConverter

public boolean isSupportDtd()

{
    return this.supportDtd;
}
org.springframework.http.converter.xml.SourceHttpMessageConverter

@Override @SuppressWarnings("unchecked") protected T readInternal(Class<?> clazz, HttpInputMessage inputMessage)

{
    InputStream body = inputMessage.getBody();
    if (DOMSource.class == clazz) {
        return (T)readDOMSource(body, inputMessage);
    } else if (SAXSource.class == clazz) {
        return (T)readSAXSource(body, inputMessage);
    } else if (StAXSource.class == clazz) {
        return (T)readStAXSource(body, inputMessage);
    } else if (StreamSource.class == clazz || Source.class == clazz) {
        return (T)readStreamSource(body);
    } else {
        throw new HttpMessageNotReadableException("Could not read class [" + clazz + "]. Only DOMSource, SAXSource, StAXSource, and StreamSource are supported.", inputMessage);
    }
}
org.springframework.http.converter.xml.SourceHttpMessageConverter

public void setProcessExternalEntities(boolean processExternalEntities)

{
    this.processExternalEntities = processExternalEntities;
    if (processExternalEntities) {
        this.supportDtd = true;
    } 
}
org.springframework.http.converter.xml.SourceHttpMessageConverter

public void setSupportDtd(boolean supportDtd)

{
    this.supportDtd = supportDtd;
}
org.springframework.http.converter.xml.SourceHttpMessageConverter

@Override public boolean supports(Class<?> clazz)

{
    return SUPPORTED_CLASSES.contains(clazz);
}
org.springframework.http.converter.xml.SourceHttpMessageConverter

@Override protected void writeInternal(T t, HttpOutputMessage outputMessage)

{
    try {
        Result result = new StreamResult(outputMessage.getBody());
        transform(t, result);
    } catch (TransformerException ex) {
        throw new HttpMessageNotWritableException("Could not transform [" + t + "] to output message", ex);
    }
}



DefaultPathContainer
implements PathContainer

org.springframework.http.server.DefaultPathContainer

@Override public List<Element> elements()

{
    return this.elements;
}
org.springframework.http.server.DefaultPathContainer

@Override public boolean equals(@Nullable Object other)

{
    if (this == other) {
        return true;
    } 
    if (!(other instanceof PathContainer)) {
        return false;
    } 
    return value().equals(((PathContainer)other).value());
}
org.springframework.http.server.DefaultPathContainer

@Override public int hashCode()

{
    return this.path.hashCode();
}
org.springframework.http.server.DefaultPathContainer

@Override public String toString()

{
    return value();
}
org.springframework.http.server.DefaultPathContainer

@Override public String value()

{
    return this.path;
}

DefaultRequestPath
implements RequestPath

org.springframework.http.server.DefaultRequestPath

@Override public PathContainer contextPath()

{
    return this.contextPath;
}
org.springframework.http.server.DefaultRequestPath

@Override public List<Element> elements()

{
    return this.fullPath.elements();
}
org.springframework.http.server.DefaultRequestPath

@Override public boolean equals(@Nullable Object other)

{
    if (this == other) {
        return true;
    } 
    if (other == null || getClass() != other.getClass()) {
        return false;
    } 
    DefaultRequestPath otherPath = (DefaultRequestPath)other;
    return (this.fullPath.equals(otherPath.fullPath) && this.contextPath.equals(otherPath.contextPath) && this.pathWithinApplication.equals(otherPath.pathWithinApplication));
}
org.springframework.http.server.DefaultRequestPath

@Override public RequestPath modifyContextPath(String contextPath)

{
    return new DefaultRequestPath(this, contextPath);
}
org.springframework.http.server.DefaultRequestPath

@Override public PathContainer pathWithinApplication()

{
    return this.pathWithinApplication;
}
org.springframework.http.server.DefaultRequestPath

@Override public String toString()

{
    return this.fullPath.toString();
}
org.springframework.http.server.DefaultRequestPath

@Override public String value()

{
    return this.fullPath.value();
}

PathContainer

RequestPath
inherit classes
  • PathContainer

ServerHttpAsyncRequestControl

ServerHttpRequest
inherit classes
  • HttpRequest
  • HttpInputMessage

ServerHttpResponse
inherit classes
  • HttpOutputMessage
  • Flushable
  • Closeable

ServletServerHttpAsyncRequestControl
implements ServerHttpAsyncRequestControl, AsyncListener

org.springframework.http.server.ServletServerHttpAsyncRequestControl

@Override public void complete()

{
    if (this.asyncContext != null && isStarted() && !isCompleted()) {
        this.asyncContext.complete();
    } 
}
org.springframework.http.server.ServletServerHttpAsyncRequestControl

@Override public boolean isCompleted()

{
    return this.asyncCompleted.get();
}
org.springframework.http.server.ServletServerHttpAsyncRequestControl

@Override public boolean isStarted()

{
    return (this.asyncContext != null && this.request.getServletRequest().isAsyncStarted());
}
org.springframework.http.server.ServletServerHttpAsyncRequestControl

@Override public void onComplete(AsyncEvent event)

{
    this.asyncContext = null;
    this.asyncCompleted.set(true);
}
org.springframework.http.server.ServletServerHttpAsyncRequestControl

@Override public void onError(AsyncEvent event)

{
}
org.springframework.http.server.ServletServerHttpAsyncRequestControl

@Override public void onStartAsync(AsyncEvent event)

{
}
org.springframework.http.server.ServletServerHttpAsyncRequestControl

@Override public void onTimeout(AsyncEvent event)

{
}
org.springframework.http.server.ServletServerHttpAsyncRequestControl

@Override public void start()

{
    start(NO_TIMEOUT_VALUE);
}
org.springframework.http.server.ServletServerHttpAsyncRequestControl

@Override public void start(long timeout)

{
    Assert.state(!isCompleted(), "Async processing has already completed");
    if (isStarted()) {
        return ;
    } 
    HttpServletRequest servletRequest = this.request.getServletRequest();
    HttpServletResponse servletResponse = this.response.getServletResponse();
    this.asyncContext = servletRequest.startAsync(servletRequest, servletResponse);
    this.asyncContext.addListener(this);
    if (timeout != NO_TIMEOUT_VALUE) {
        this.asyncContext.setTimeout(timeout);
    } 
}

ServletServerHttpRequest
implements ServerHttpRequest

org.springframework.http.server.ServletServerHttpRequest

protected static final Charset FORM_CHARSET

org.springframework.http.server.ServletServerHttpRequest

protected static final String FORM_CONTENT_TYPE

org.springframework.http.server.ServletServerHttpRequest

public ServletServerHttpRequest ServletServerHttpRequest(HttpServletRequest servletRequest)

{
    Assert.notNull(servletRequest, "HttpServletRequest must not be null");
    this.servletRequest = servletRequest;
}
org.springframework.http.server.ServletServerHttpRequest

@Override public ServerHttpAsyncRequestControl getAsyncRequestControl(ServerHttpResponse response)

{
    if (this.asyncRequestControl == null) {
        if (!ServletServerHttpResponse.class.isInstance(response)) {
            throw new IllegalArgumentException("Response must be a ServletServerHttpResponse: " + response.getClass());
        } 
        ServletServerHttpResponse servletServerResponse = (ServletServerHttpResponse)response;
        this.asyncRequestControl = new ServletServerHttpAsyncRequestControl(this, servletServerResponse);
    } 
    return this.asyncRequestControl;
}
org.springframework.http.server.ServletServerHttpRequest

@Override public HttpHeaders getHeaders()

{
    if (this.headers == null) {
        this.headers = new HttpHeaders();
        for (Enumeration<?> names = this.servletRequest.getHeaderNames(); names.hasMoreElements(); ) {
            String headerName = (String)names.nextElement();
            for (Enumeration<?> headerValues = this.servletRequest.getHeaders(headerName); headerValues.hasMoreElements(); ) {
                String headerValue = (String)headerValues.nextElement();
                this.headers.add(headerName, headerValue);
            }
        }
        try {
            MediaType contentType = this.headers.getContentType();
            if (contentType == null) {
                String requestContentType = this.servletRequest.getContentType();
                if (StringUtils.hasLength(requestContentType)) {
                    contentType = MediaType.parseMediaType(requestContentType);
                    this.headers.setContentType(contentType);
                } 
            } 
            if (contentType != null && contentType.getCharset() == null) {
                String requestEncoding = this.servletRequest.getCharacterEncoding();
                if (StringUtils.hasLength(requestEncoding)) {
                    Charset charSet = Charset.forName(requestEncoding);
                    Map<String, String> params = new LinkedCaseInsensitiveMap<>();
                    params.putAll(contentType.getParameters());
                    params.put("charset", charSet.toString());
                    MediaType mediaType = new MediaType(contentType.getType(), contentType.getSubtype(), params);
                    this.headers.setContentType(mediaType);
                } 
            } 
        } catch (InvalidMediaTypeException ex) {
        }
        if (this.headers.getContentLength() < 0) {
            int requestContentLength = this.servletRequest.getContentLength();
            if (requestContentLength != -1) {
                this.headers.setContentLength(requestContentLength);
            } 
        } 
    } 
    return this.headers;
}
org.springframework.http.server.ServletServerHttpRequest

@Override public InetSocketAddress getLocalAddress()

{
    return new InetSocketAddress(this.servletRequest.getLocalName(), this.servletRequest.getLocalPort());
}
org.springframework.http.server.ServletServerHttpRequest

@Override @Nullable public HttpMethod getMethod()

{
    return HttpMethod.resolve(this.servletRequest.getMethod());
}
org.springframework.http.server.ServletServerHttpRequest

@Override public String getMethodValue()

{
    return this.servletRequest.getMethod();
}
org.springframework.http.server.ServletServerHttpRequest

@Override public Principal getPrincipal()

{
    return this.servletRequest.getUserPrincipal();
}
org.springframework.http.server.ServletServerHttpRequest

@Override public InetSocketAddress getRemoteAddress()

{
    return new InetSocketAddress(this.servletRequest.getRemoteHost(), this.servletRequest.getRemotePort());
}
org.springframework.http.server.ServletServerHttpRequest

public HttpServletRequest getServletRequest()

{
    return this.servletRequest;
}

ServletServerHttpResponse
implements ServerHttpResponse

org.springframework.http.server.ServletServerHttpResponse

public ServletServerHttpResponse ServletServerHttpResponse(HttpServletResponse servletResponse)

{
    Assert.notNull(servletResponse, "HttpServletResponse must not be null");
    this.servletResponse = servletResponse;
    this.headers = new ServletResponseHttpHeaders();
}
org.springframework.http.server.ServletServerHttpResponse

@Override public void close()

{
    writeHeaders();
}
org.springframework.http.server.ServletServerHttpResponse

@Override public void flush()

{
    writeHeaders();
    if (this.bodyUsed) {
        this.servletResponse.flushBuffer();
    } 
}
org.springframework.http.server.ServletServerHttpResponse

@Override public OutputStream getBody()

{
    this.bodyUsed = true;
    writeHeaders();
    return this.servletResponse.getOutputStream();
}
org.springframework.http.server.ServletServerHttpResponse

@Override public HttpHeaders getHeaders()

{
    return (this.headersWritten ? HttpHeaders.readOnlyHttpHeaders(this.headers) : this.headers);
}
org.springframework.http.server.ServletServerHttpResponse

public HttpServletResponse getServletResponse()

{
    return this.servletResponse;
}
org.springframework.http.server.ServletServerHttpResponse

@Override public void setStatusCode(HttpStatus status)

{
    Assert.notNull(status, "HttpStatus must not be null");
    this.servletResponse.setStatus(status.value());
}


AbstractListenerReadPublisher<T>
implements Publisher<T>

org.springframework.http.server.reactive.AbstractListenerReadPublisher

public AbstractListenerReadPublisher AbstractListenerReadPublisher()

{
    this("");
}
org.springframework.http.server.reactive.AbstractListenerReadPublisher

public AbstractListenerReadPublisher AbstractListenerReadPublisher(String logPrefix)

{
    this.logPrefix = logPrefix;
}
org.springframework.http.server.reactive.AbstractListenerReadPublisher

protected abstract void checkOnDataAvailable()

org.springframework.http.server.reactive.AbstractListenerReadPublisher

volatile boolean completionBeforeDemand

org.springframework.http.server.reactive.AbstractListenerReadPublisher

volatile long demand

org.springframework.http.server.reactive.AbstractListenerReadPublisher

protected abstract void discardData()

org.springframework.http.server.reactive.AbstractListenerReadPublisher

@Nullable volatile Throwable errorBeforeDemand

org.springframework.http.server.reactive.AbstractListenerReadPublisher

public String getLogPrefix()

{
    return this.logPrefix;
}
org.springframework.http.server.reactive.AbstractListenerReadPublisher

public void onAllDataRead()

{
    rsReadLogger.trace(getLogPrefix() + "onAllDataRead");
    this.state.get().onAllDataRead(this);
}
org.springframework.http.server.reactive.AbstractListenerReadPublisher

public final void onDataAvailable()

{
    rsReadLogger.trace(getLogPrefix() + "onDataAvailable");
    this.state.get().onDataAvailable(this);
}
org.springframework.http.server.reactive.AbstractListenerReadPublisher

public final void onError(Throwable ex)

{
    if (rsReadLogger.isTraceEnabled()) {
        rsReadLogger.trace(getLogPrefix() + "Connection error: " + ex);
    } 
    this.state.get().onError(this, ex);
}
org.springframework.http.server.reactive.AbstractListenerReadPublisher

@Nullable protected abstract T read()

org.springframework.http.server.reactive.AbstractListenerReadPublisher

protected abstract void readingPaused()

org.springframework.http.server.reactive.AbstractListenerReadPublisher

protected static Log rsReadLogger

org.springframework.http.server.reactive.AbstractListenerReadPublisher

@Override public void subscribe(Subscriber<?> subscriber)

{
    this.state.get().subscribe(this, subscriber);
}
org.springframework.http.server.reactive.AbstractListenerReadPublisher

@Nullable volatile Subscriber<?> subscriber


AbstractListenerServerHttpResponse
extends AbstractServerHttpResponse

org.springframework.http.server.reactive.AbstractListenerServerHttpResponse

public AbstractListenerServerHttpResponse AbstractListenerServerHttpResponse(DataBufferFactory dataBufferFactory)

{
    super(dataBufferFactory);
}
org.springframework.http.server.reactive.AbstractListenerServerHttpResponse

public AbstractListenerServerHttpResponse AbstractListenerServerHttpResponse(DataBufferFactory dataBufferFactory, HttpHeaders headers)

{
    super(dataBufferFactory, headers);
}
org.springframework.http.server.reactive.AbstractListenerServerHttpResponse

protected abstract Processor<?, Void> createBodyFlushProcessor()

org.springframework.http.server.reactive.AbstractListenerServerHttpResponse

@Override protected final Mono<Void> writeAndFlushWithInternal(Publisher<?> body)

{
    if (this.writeCalled.compareAndSet(false, true)) {
        Processor<? super Publisher<? extends DataBuffer>, Void> processor = createBodyFlushProcessor();
        return Mono.from(subscriber -> {
            body.subscribe(processor);
            processor.subscribe(subscriber);
        });
    } 
    return Mono.error(new IllegalStateException("writeWith() or writeAndFlushWith() has already been called"));
}
org.springframework.http.server.reactive.AbstractListenerServerHttpResponse

@Override protected final Mono<Void> writeWithInternal(Publisher<?> body)

{
    return writeAndFlushWithInternal(Mono.just(body));
}

AbstractListenerWriteFlushProcessor<T>
implements Processor<Publisher<?>, Void>

org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor

public AbstractListenerWriteFlushProcessor AbstractListenerWriteFlushProcessor()

{
    this("");
}
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor

public AbstractListenerWriteFlushProcessor AbstractListenerWriteFlushProcessor(String logPrefix)

{
    this.logPrefix = logPrefix;
    this.resultPublisher = new WriteResultPublisher(logPrefix);
}
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor

protected void cancel()

{
    if (rsWriteFlushLogger.isTraceEnabled()) {
        rsWriteFlushLogger.trace(getLogPrefix() + "Received request to cancel");
    } 
    if (this.subscription != null) {
        this.subscription.cancel();
    } 
}
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor

protected abstract Processor<?, Void> createWriteProcessor()

org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor

protected abstract void flush()

org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor

protected void flushingFailed(Throwable t)

{
}
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor

public String getLogPrefix()

{
    return this.logPrefix;
}
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor

protected abstract boolean isFlushPending()

org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor

protected abstract boolean isWritePossible()

org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor

@Override public final void onComplete()

{
    if (rsWriteFlushLogger.isTraceEnabled()) {
        rsWriteFlushLogger.trace(getLogPrefix() + "Received onComplete");
    } 
    this.state.get().onComplete(this);
}
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor

@Override public final void onError(Throwable ex)

{
    if (rsWriteFlushLogger.isTraceEnabled()) {
        rsWriteFlushLogger.trace(getLogPrefix() + "Received onError: " + ex);
    } 
    this.state.get().onError(this, ex);
}
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor

protected final void onFlushPossible()

{
    this.state.get().onFlushPossible(this);
}
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor

@Override public final void onNext(Publisher<?> publisher)

{
    if (rsWriteFlushLogger.isTraceEnabled()) {
        rsWriteFlushLogger.trace(getLogPrefix() + "Received onNext publisher");
    } 
    this.state.get().onNext(this, publisher);
}
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor

@Override public final void onSubscribe(Subscription subscription)

{
    this.state.get().onSubscribe(this, subscription);
}
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor

protected static final Log rsWriteFlushLogger

org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor

@Override public final void subscribe(Subscriber<?> subscriber)

{
    this.resultPublisher.subscribe(subscriber);
}
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor

volatile boolean subscriberCompleted


AbstractListenerWriteProcessor<T>
implements Processor<T, Void>

org.springframework.http.server.reactive.AbstractListenerWriteProcessor

public AbstractListenerWriteProcessor AbstractListenerWriteProcessor()

{
    this("");
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor

public AbstractListenerWriteProcessor AbstractListenerWriteProcessor(String logPrefix)

{
    this.logPrefix = logPrefix;
    this.resultPublisher = new WriteResultPublisher(logPrefix);
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor

public void cancel()

{
    rsWriteLogger.trace(getLogPrefix() + "Cancellation");
    if (this.subscription != null) {
        this.subscription.cancel();
    } 
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor

@Nullable volatile T currentData

org.springframework.http.server.reactive.AbstractListenerWriteProcessor

protected void dataReceived(T data)

{
    T prev = this.currentData;
    if (prev != null) {
        discardData(data);
        cancel();
        onError(new IllegalStateException("Received new data while current not processed yet."));
    } 
    this.currentData = data;
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor

protected abstract void discardData(T data)

org.springframework.http.server.reactive.AbstractListenerWriteProcessor

public String getLogPrefix()

{
    return this.logPrefix;
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor

protected abstract boolean isDataEmpty(T data)

org.springframework.http.server.reactive.AbstractListenerWriteProcessor

protected abstract boolean isWritePossible()

org.springframework.http.server.reactive.AbstractListenerWriteProcessor

@Override public final void onComplete()

{
    if (rsWriteLogger.isTraceEnabled()) {
        rsWriteLogger.trace(getLogPrefix() + "No more items to write");
    } 
    this.state.get().onComplete(this);
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor

@Override public final void onError(Throwable ex)

{
    if (rsWriteLogger.isTraceEnabled()) {
        rsWriteLogger.trace(getLogPrefix() + "Write source error: " + ex);
    } 
    this.state.get().onError(this, ex);
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor

@Override public final void onNext(T data)

{
    if (rsWriteLogger.isTraceEnabled()) {
        rsWriteLogger.trace(getLogPrefix() + "Item to write");
    } 
    this.state.get().onNext(this, data);
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor

@Override public final void onSubscribe(Subscription subscription)

{
    this.state.get().onSubscribe(this, subscription);
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor

public final void onWritePossible()

{
    if (rsWriteLogger.isTraceEnabled()) {
        rsWriteLogger.trace(getLogPrefix() + "onWritePossible");
    } 
    this.state.get().onWritePossible(this);
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor

protected static final Log rsWriteLogger

org.springframework.http.server.reactive.AbstractListenerWriteProcessor

@Override public final void subscribe(Subscriber<?> subscriber)

{
    this.resultPublisher.subscribe(subscriber);
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor

volatile boolean subscriberCompleted

org.springframework.http.server.reactive.AbstractListenerWriteProcessor

protected abstract boolean write(T data)

org.springframework.http.server.reactive.AbstractListenerWriteProcessor

protected void writingComplete()

{
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor

protected void writingFailed(Throwable ex)

{
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor

@Deprecated protected void writingPaused()

{
}

AbstractServerHttpRequest
implements ServerHttpRequest

org.springframework.http.server.reactive.AbstractServerHttpRequest

public AbstractServerHttpRequest AbstractServerHttpRequest(URI uri, @Nullable String contextPath, HttpHeaders headers)

{
    this.uri = uri;
    this.path = RequestPath.parse(uri, contextPath);
    this.headers = HttpHeaders.readOnlyHttpHeaders(headers);
}
org.springframework.http.server.reactive.AbstractServerHttpRequest

@Override public MultiValueMap<String, HttpCookie> getCookies()

{
    if (this.cookies == null) {
        this.cookies = CollectionUtils.unmodifiableMultiValueMap(initCookies());
    } 
    return this.cookies;
}
org.springframework.http.server.reactive.AbstractServerHttpRequest

@Override public HttpHeaders getHeaders()

{
    return this.headers;
}
org.springframework.http.server.reactive.AbstractServerHttpRequest

@Override public String getId()

{
    if (this.id == null) {
        this.id = initId();
        if (this.id == null) {
            this.id = ObjectUtils.getIdentityHexString(this);
        } 
    } 
    return this.id;
}
org.springframework.http.server.reactive.AbstractServerHttpRequest

<T>public abstract T getNativeRequest()

org.springframework.http.server.reactive.AbstractServerHttpRequest

@Override public RequestPath getPath()

{
    return this.path;
}
org.springframework.http.server.reactive.AbstractServerHttpRequest

@Override public MultiValueMap<String, String> getQueryParams()

{
    if (this.queryParams == null) {
        this.queryParams = CollectionUtils.unmodifiableMultiValueMap(initQueryParams());
    } 
    return this.queryParams;
}
org.springframework.http.server.reactive.AbstractServerHttpRequest

@Nullable @Override public SslInfo getSslInfo()

{
    if (this.sslInfo == null) {
        this.sslInfo = initSslInfo();
    } 
    return this.sslInfo;
}
org.springframework.http.server.reactive.AbstractServerHttpRequest

@Override public URI getURI()

{
    return this.uri;
}
org.springframework.http.server.reactive.AbstractServerHttpRequest

protected abstract MultiValueMap<String, HttpCookie> initCookies()

org.springframework.http.server.reactive.AbstractServerHttpRequest

@Nullable protected String initId()

{
    return null;
}
org.springframework.http.server.reactive.AbstractServerHttpRequest

@Nullable protected abstract SslInfo initSslInfo()

org.springframework.http.server.reactive.AbstractServerHttpRequest

protected final Log logger


AbstractServerHttpResponse
implements ServerHttpResponse

org.springframework.http.server.reactive.AbstractServerHttpResponse

public AbstractServerHttpResponse AbstractServerHttpResponse(DataBufferFactory dataBufferFactory)

{
    this(dataBufferFactory, new HttpHeaders());
}
org.springframework.http.server.reactive.AbstractServerHttpResponse

public AbstractServerHttpResponse AbstractServerHttpResponse(DataBufferFactory dataBufferFactory, HttpHeaders headers)

{
    Assert.notNull(dataBufferFactory, "DataBufferFactory must not be null");
    Assert.notNull(headers, "HttpHeaders must not be null");
    this.dataBufferFactory = dataBufferFactory;
    this.headers = headers;
    this.cookies = new LinkedMultiValueMap<>();
}
org.springframework.http.server.reactive.AbstractServerHttpResponse

protected abstract void applyCookies()

org.springframework.http.server.reactive.AbstractServerHttpResponse

protected abstract void applyHeaders()

org.springframework.http.server.reactive.AbstractServerHttpResponse

protected abstract void applyStatusCode()

org.springframework.http.server.reactive.AbstractServerHttpResponse

@Override public void beforeCommit(Supplier<?> action)

{
    this.commitActions.add(action);
}
org.springframework.http.server.reactive.AbstractServerHttpResponse

@Override public final DataBufferFactory bufferFactory()

{
    return this.dataBufferFactory;
}
org.springframework.http.server.reactive.AbstractServerHttpResponse

protected Mono<Void> doCommit()

{
    return doCommit(null);
}
org.springframework.http.server.reactive.AbstractServerHttpResponse

protected Mono<Void> doCommit(@Nullable Supplier<?> writeAction)

{
    if (!this.state.compareAndSet(State.NEW, State.COMMITTING)) {
        return Mono.empty();
    } 
    this.commitActions.add(() -> Mono.fromRunnable(() -> {
        applyStatusCode();
        applyHeaders();
        applyCookies();
        this.state.set(State.COMMITTED);
    }));
    if (writeAction != null) {
        this.commitActions.add(writeAction);
    } 
    Flux<Void> commit = Flux.empty();
    for (Supplier<? extends Mono<Void>> action: this.commitActions) {
        commit = commit.concatWith(action.get());
    }
    return commit.then();
}
org.springframework.http.server.reactive.AbstractServerHttpResponse

@Override public MultiValueMap<String, ResponseCookie> getCookies()

{
    return (this.state.get() == State.COMMITTED ? CollectionUtils.unmodifiableMultiValueMap(this.cookies) : this.cookies);
}
org.springframework.http.server.reactive.AbstractServerHttpResponse

@Override public HttpHeaders getHeaders()

{
    return (this.state.get() == State.COMMITTED ? HttpHeaders.readOnlyHttpHeaders(this.headers) : this.headers);
}
org.springframework.http.server.reactive.AbstractServerHttpResponse

<T>public abstract T getNativeResponse()

org.springframework.http.server.reactive.AbstractServerHttpResponse

@Override @Nullable public HttpStatus getStatusCode()

{
    return (this.statusCode != null ? HttpStatus.resolve(this.statusCode) : null);
}
org.springframework.http.server.reactive.AbstractServerHttpResponse

@Nullable public Integer getStatusCodeValue()

{
    return this.statusCode;
}
org.springframework.http.server.reactive.AbstractServerHttpResponse

@Override public boolean isCommitted()

{
    return this.state.get() != State.NEW;
}
org.springframework.http.server.reactive.AbstractServerHttpResponse

protected final Log logger

org.springframework.http.server.reactive.AbstractServerHttpResponse

@Override public Mono<Void> setComplete()

{
    return !isCommitted() ? doCommit(null) : Mono.empty();
}
org.springframework.http.server.reactive.AbstractServerHttpResponse

@Override public boolean setStatusCode(@Nullable HttpStatus status)

{
    if (this.state.get() == State.COMMITTED) {
        return false;
    } else {
        this.statusCode = (status != null ? status.value() : null);
        return true;
    }
}
org.springframework.http.server.reactive.AbstractServerHttpResponse

public void setStatusCodeValue(@Nullable Integer statusCode)

{
    this.statusCode = statusCode;
}
org.springframework.http.server.reactive.AbstractServerHttpResponse

@Override public final Mono<Void> writeAndFlushWith(Publisher<?> body)

{
    return new ChannelSendOperator<>(body, inner -> doCommit(() -> writeAndFlushWithInternal(inner))).doOnError(t -> removeContentLength());
}
org.springframework.http.server.reactive.AbstractServerHttpResponse

protected abstract Mono<Void> writeAndFlushWithInternal(Publisher<?> body)

org.springframework.http.server.reactive.AbstractServerHttpResponse

@Override @SuppressWarnings("unchecked") public final Mono<Void> writeWith(Publisher<?> body)

{
    if (body instanceof Mono) {
        return ((Mono<? extends DataBuffer>)body).flatMap(buffer -> doCommit(() -> writeWithInternal(Mono.just(buffer))).doOnDiscard(PooledDataBuffer.class, DataBufferUtils::release));
    } 
    return new ChannelSendOperator<>(body, inner -> doCommit(() -> writeWithInternal(inner))).doOnError(t -> removeContentLength());
}
org.springframework.http.server.reactive.AbstractServerHttpResponse

protected abstract Mono<Void> writeWithInternal(Publisher<?> body)


ChannelSendOperator<T>
extends Mono<Void> implements Scannable

org.springframework.http.server.reactive.ChannelSendOperator

public ChannelSendOperator ChannelSendOperator(Publisher<?> source, Function<Publisher<T>, Publisher<Void>> writeFunction)

{
    this.source = Flux.from(source);
    this.writeFunction = writeFunction;
}
org.springframework.http.server.reactive.ChannelSendOperator

@Override @Nullable @SuppressWarnings("rawtypes") public Object scanUnsafe(Attr key)

{
    if (key == Attr.PREFETCH) {
        return Integer.MAX_VALUE;
    } 
    if (key == Attr.PARENT) {
        return this.source;
    } 
    return null;
}
org.springframework.http.server.reactive.ChannelSendOperator

@Override public void subscribe(CoreSubscriber<?> actual)

{
    this.source.subscribe(new WriteBarrier(actual));
}

DefaultServerHttpRequestBuilder
implements ServerHttpRequest.Builder

org.springframework.http.server.reactive.DefaultServerHttpRequestBuilder

@Override public ServerHttpRequest.Builder contextPath(String contextPath)

{
    this.contextPath = contextPath;
    return this;
}
org.springframework.http.server.reactive.DefaultServerHttpRequestBuilder

@Override public ServerHttpRequest.Builder header(String headerName, String... headerValues)

{
    this.httpHeaders.put(headerName, Arrays.asList(headerValues));
    return this;
}
org.springframework.http.server.reactive.DefaultServerHttpRequestBuilder

@Override public ServerHttpRequest.Builder headers(Consumer<HttpHeaders> headersConsumer)

{
    Assert.notNull(headersConsumer, "'headersConsumer' must not be null");
    headersConsumer.accept(this.httpHeaders);
    return this;
}
org.springframework.http.server.reactive.DefaultServerHttpRequestBuilder

@Override public ServerHttpRequest.Builder method(HttpMethod httpMethod)

{
    this.httpMethodValue = httpMethod.name();
    return this;
}
org.springframework.http.server.reactive.DefaultServerHttpRequestBuilder

@Override public ServerHttpRequest.Builder path(String path)

{
    Assert.isTrue(path.startsWith("/"), "The path does not have a leading slash.");
    this.uriPath = path;
    return this;
}
org.springframework.http.server.reactive.DefaultServerHttpRequestBuilder

@Override public ServerHttpRequest.Builder sslInfo(SslInfo sslInfo)

{
    this.sslInfo = sslInfo;
    return this;
}
org.springframework.http.server.reactive.DefaultServerHttpRequestBuilder

@Override public ServerHttpRequest.Builder uri(URI uri)

{
    this.uri = uri;
    return this;
}

DefaultSslInfo
implements SslInfo

org.springframework.http.server.reactive.DefaultSslInfo

@Override @Nullable public X509Certificate[] getPeerCertificates()

{
    return this.peerCertificates;
}
org.springframework.http.server.reactive.DefaultSslInfo

@Override @Nullable public String getSessionId()

{
    return this.sessionId;
}

HttpHandler

HttpHeadResponseDecorator
extends ServerHttpResponseDecorator

org.springframework.http.server.reactive.HttpHeadResponseDecorator

public HttpHeadResponseDecorator HttpHeadResponseDecorator(ServerHttpResponse delegate)

{
    super(delegate);
}
org.springframework.http.server.reactive.HttpHeadResponseDecorator

@Override public final Mono<Void> writeAndFlushWith(Publisher<?> body)

{
    return setComplete();
}

JettyHeadersAdapter
implements MultiValueMap<String, String>

org.springframework.http.server.reactive.JettyHeadersAdapter

@Override public void add(String key, @Nullable String value)

{
    this.headers.add(key, value);
}
org.springframework.http.server.reactive.JettyHeadersAdapter

@Override public void addAll(String key, List<?> values)

{
    values.forEach(value -> add(key, value));
}
org.springframework.http.server.reactive.JettyHeadersAdapter

@Override public void addAll(MultiValueMap<String, String> values)

{
    values.forEach(this::addAll);
}
org.springframework.http.server.reactive.JettyHeadersAdapter

@Override public void clear()

{
    this.headers.clear();
}
org.springframework.http.server.reactive.JettyHeadersAdapter

@Override public boolean containsKey(Object key)

{
    return (key instanceof String && this.headers.containsKey((String)key));
}
org.springframework.http.server.reactive.JettyHeadersAdapter

@Override public boolean containsValue(Object value)

{
    return (value instanceof String && this.headers.stream().anyMatch(field -> field.contains((String)value)));
}
org.springframework.http.server.reactive.JettyHeadersAdapter

@Override public Set<Entry<String, List<String>>> entrySet()

{
    return new AbstractSet<Entry<String, List<String>>>() {
        @Override
        public Iterator<Entry<String, List<String>>> iterator() {
            return new EntryIterator();
        }
        @Override
        public int size() {
            return headers.size();
        }
    };
}
org.springframework.http.server.reactive.JettyHeadersAdapter

@Nullable @Override public List<String> get(Object key)

{
    if (containsKey(key)) {
        return this.headers.getValuesList((String)key);
    } 
    return null;
}
org.springframework.http.server.reactive.JettyHeadersAdapter

@Override public String getFirst(String key)

{
    return this.headers.get(key);
}
org.springframework.http.server.reactive.JettyHeadersAdapter

@Override public boolean isEmpty()

{
    return (this.headers.size() == 0);
}
org.springframework.http.server.reactive.JettyHeadersAdapter

@Override public Set<String> keySet()

{
    return this.headers.getFieldNamesCollection();
}
org.springframework.http.server.reactive.JettyHeadersAdapter

@Nullable @Override public List<String> put(String key, List<String> value)

{
    List<String> oldValues = get(key);
    this.headers.put(key, value);
    return oldValues;
}
org.springframework.http.server.reactive.JettyHeadersAdapter

@Override public void putAll(Map<?, ?> map)

{
    map.forEach(this::put);
}
org.springframework.http.server.reactive.JettyHeadersAdapter

@Nullable @Override public List<String> remove(Object key)

{
    if (key instanceof String) {
        List<String> oldValues = get(key);
        this.headers.remove((String)key);
        return oldValues;
    } 
    return null;
}
org.springframework.http.server.reactive.JettyHeadersAdapter

@Override public void set(String key, @Nullable String value)

{
    this.headers.put(key, value);
}
org.springframework.http.server.reactive.JettyHeadersAdapter

@Override public void setAll(Map<String, String> values)

{
    values.forEach(this::set);
}
org.springframework.http.server.reactive.JettyHeadersAdapter

@Override public int size()

{
    return this.headers.getFieldNamesCollection().size();
}
org.springframework.http.server.reactive.JettyHeadersAdapter

@Override public String toString()

{
    return HttpHeaders.formatHeaders(this);
}
org.springframework.http.server.reactive.JettyHeadersAdapter

@Override public Collection<List<String>> values()

{
    return this.headers.getFieldNamesCollection().stream().map(this.headers::getValuesList).collect(Collectors.toList());
}

JettyHttpHandlerAdapter
extends ServletHttpHandlerAdapter

org.springframework.http.server.reactive.JettyHttpHandlerAdapter

public JettyHttpHandlerAdapter JettyHttpHandlerAdapter(HttpHandler httpHandler)

{
    super(httpHandler);
}
org.springframework.http.server.reactive.JettyHttpHandlerAdapter

@Override protected ServletServerHttpRequest createRequest(HttpServletRequest request, AsyncContext context)

{
    Assert.notNull(getServletPath(), "Servlet path is not initialized");
    return new JettyServerHttpRequest(request, context, getServletPath(), getDataBufferFactory(), getBufferSize());
}
org.springframework.http.server.reactive.JettyHttpHandlerAdapter

@Override protected ServletServerHttpResponse createResponse(HttpServletResponse response, AsyncContext context, ServletServerHttpRequest request)

{
    return new JettyServerHttpResponse(response, context, getDataBufferFactory(), getBufferSize(), request);
}

NettyHeadersAdapter
implements MultiValueMap<String, String>

org.springframework.http.server.reactive.NettyHeadersAdapter

@Override public void add(String key, @Nullable String value)

{
    this.headers.add(key, value);
}
org.springframework.http.server.reactive.NettyHeadersAdapter

@Override public void addAll(String key, List<?> values)

{
    this.headers.add(key, values);
}
org.springframework.http.server.reactive.NettyHeadersAdapter

@Override public void addAll(MultiValueMap<String, String> values)

{
    values.forEach(this.headers::add);
}
org.springframework.http.server.reactive.NettyHeadersAdapter

@Override public void clear()

{
    this.headers.clear();
}
org.springframework.http.server.reactive.NettyHeadersAdapter

@Override public boolean containsKey(Object key)

{
    return (key instanceof String && this.headers.contains((String)key));
}
org.springframework.http.server.reactive.NettyHeadersAdapter

@Override public boolean containsValue(Object value)

{
    return (value instanceof String && this.headers.entries().stream().anyMatch(entry -> value.equals(entry.getValue())));
}
org.springframework.http.server.reactive.NettyHeadersAdapter

@Override public Set<Entry<String, List<String>>> entrySet()

{
    return new AbstractSet<Entry<String, List<String>>>() {
        @Override
        public Iterator<Entry<String, List<String>>> iterator() {
            return new EntryIterator();
        }
        @Override
        public int size() {
            return headers.size();
        }
    };
}
org.springframework.http.server.reactive.NettyHeadersAdapter

@Override @Nullable public List<String> get(Object key)

{
    if (containsKey(key)) {
        return this.headers.getAll((String)key);
    } 
    return null;
}
org.springframework.http.server.reactive.NettyHeadersAdapter

@Override @Nullable public String getFirst(String key)

{
    return this.headers.get(key);
}
org.springframework.http.server.reactive.NettyHeadersAdapter

@Override public boolean isEmpty()

{
    return this.headers.isEmpty();
}
org.springframework.http.server.reactive.NettyHeadersAdapter

@Override public Set<String> keySet()

{
    return this.headers.names();
}
org.springframework.http.server.reactive.NettyHeadersAdapter

@Nullable @Override public List<String> put(String key, @Nullable List<String> value)

{
    List<String> previousValues = this.headers.getAll(key);
    this.headers.set(key, value);
    return previousValues;
}
org.springframework.http.server.reactive.NettyHeadersAdapter

@Override public void putAll(Map<?, ?> map)

{
    map.forEach(this.headers::add);
}
org.springframework.http.server.reactive.NettyHeadersAdapter

@Nullable @Override public List<String> remove(Object key)

{
    if (key instanceof String) {
        List<String> previousValues = this.headers.getAll((String)key);
        this.headers.remove((String)key);
        return previousValues;
    } 
    return null;
}
org.springframework.http.server.reactive.NettyHeadersAdapter

@Override public void set(String key, @Nullable String value)

{
    this.headers.set(key, value);
}
org.springframework.http.server.reactive.NettyHeadersAdapter

@Override public void setAll(Map<String, String> values)

{
    values.forEach(this.headers::set);
}
org.springframework.http.server.reactive.NettyHeadersAdapter

@Override public int size()

{
    return this.headers.names().size();
}
org.springframework.http.server.reactive.NettyHeadersAdapter

@Override public String toString()

{
    return org.springframework.http.HttpHeaders.formatHeaders(this);
}
org.springframework.http.server.reactive.NettyHeadersAdapter

@Override public Collection<List<String>> values()

{
    return this.headers.names().stream().map(this.headers::getAll).collect(Collectors.toList());
}

ReactorHttpHandlerAdapter
implements BiFunction<HttpServerRequest, HttpServerResponse, Mono<Void>>

org.springframework.http.server.reactive.ReactorHttpHandlerAdapter

public ReactorHttpHandlerAdapter ReactorHttpHandlerAdapter(HttpHandler httpHandler)

{
    Assert.notNull(httpHandler, "HttpHandler must not be null");
    this.httpHandler = httpHandler;
}
org.springframework.http.server.reactive.ReactorHttpHandlerAdapter

@Override public Mono<Void> apply(HttpServerRequest reactorRequest, HttpServerResponse reactorResponse)

{
    NettyDataBufferFactory bufferFactory = new NettyDataBufferFactory(reactorResponse.alloc());
    try {
        ReactorServerHttpRequest request = new ReactorServerHttpRequest(reactorRequest, bufferFactory);
        ServerHttpResponse response = new ReactorServerHttpResponse(reactorResponse, bufferFactory);
        if (request.getMethod() == HttpMethod.HEAD) {
            response = new HttpHeadResponseDecorator(response);
        } 
        return this.httpHandler.handle(request, response).doOnError(ex -> logger.trace(request.getLogPrefix() + "Failed to complete: " + ex.getMessage())).doOnSuccess(aVoid -> logger.trace(request.getLogPrefix() + "Handling completed"));
    } catch (URISyntaxException ex) {
        if (logger.isDebugEnabled()) {
            logger.debug("Failed to get request URI: " + ex.getMessage());
        } 
        reactorResponse.status(HttpResponseStatus.BAD_REQUEST);
        return Mono.empty();
    }
}

ReactorServerHttpRequest
extends AbstractServerHttpRequest

org.springframework.http.server.reactive.ReactorServerHttpRequest

public ReactorServerHttpRequest ReactorServerHttpRequest(HttpServerRequest request, NettyDataBufferFactory bufferFactory)

{
    super(initUri(request), "", initHeaders(request));
    Assert.notNull(bufferFactory, "DataBufferFactory must not be null");
    this.request = request;
    this.bufferFactory = bufferFactory;
}
org.springframework.http.server.reactive.ReactorServerHttpRequest

@Override public Flux<DataBuffer> getBody()

{
    return this.request.receive().retain().map(this.bufferFactory::wrap);
}
org.springframework.http.server.reactive.ReactorServerHttpRequest

@Override public String getMethodValue()

{
    return this.request.method().name();
}
org.springframework.http.server.reactive.ReactorServerHttpRequest

<T>@SuppressWarnings("unchecked") @Override public T getNativeRequest()

{
    return (T)this.request;
}
org.springframework.http.server.reactive.ReactorServerHttpRequest

@Override public InetSocketAddress getRemoteAddress()

{
    return this.request.remoteAddress();
}
org.springframework.http.server.reactive.ReactorServerHttpRequest

@Override @Nullable protected String initId()

{
    return this.request instanceof Connection ? ((Connection)this.request).channel().id().asShortText() : null;
}

ReactorServerHttpResponse
extends AbstractServerHttpResponse implements ZeroCopyHttpOutputMessage

org.springframework.http.server.reactive.ReactorServerHttpResponse

public ReactorServerHttpResponse ReactorServerHttpResponse(HttpServerResponse response, DataBufferFactory bufferFactory)

{
    super(bufferFactory, new HttpHeaders(new NettyHeadersAdapter(response.responseHeaders())));
    Assert.notNull(response, "HttpServerResponse must not be null");
    this.response = response;
}
org.springframework.http.server.reactive.ReactorServerHttpResponse

@Override protected void applyHeaders()

{
}
org.springframework.http.server.reactive.ReactorServerHttpResponse

@Override protected void applyStatusCode()

{
    Integer statusCode = getStatusCodeValue();
    if (statusCode != null) {
        this.response.status(statusCode);
    } 
}
org.springframework.http.server.reactive.ReactorServerHttpResponse

<T>@SuppressWarnings("unchecked") @Override public T getNativeResponse()

{
    return (T)this.response;
}
org.springframework.http.server.reactive.ReactorServerHttpResponse

@Override public HttpStatus getStatusCode()

{
    HttpStatus httpStatus = super.getStatusCode();
    return (httpStatus != null ? httpStatus : HttpStatus.resolve(this.response.status().code()));
}
org.springframework.http.server.reactive.ReactorServerHttpResponse

@Override protected Mono<Void> writeAndFlushWithInternal(Publisher<?> publisher)

{
    return this.response.sendGroups(Flux.from(publisher).map(this::toByteBufs)).then();
}
org.springframework.http.server.reactive.ReactorServerHttpResponse

@Override public Mono<Void> writeWith(Path file, long position, long count)

{
    return doCommit(() -> this.response.sendFile(file, position, count).then());
}
org.springframework.http.server.reactive.ReactorServerHttpResponse

@Override protected Mono<Void> writeWithInternal(Publisher<?> publisher)

{
    return this.response.send(toByteBufs(publisher)).then();
}

ServerHttpRequest
inherit classes
  • HttpRequest
  • ReactiveHttpInputMessage

ServerHttpRequestDecorator
implements ServerHttpRequest

org.springframework.http.server.reactive.ServerHttpRequestDecorator

public ServerHttpRequestDecorator ServerHttpRequestDecorator(ServerHttpRequest delegate)

{
    Assert.notNull(delegate, "Delegate is required");
    this.delegate = delegate;
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator

@Override public Flux<DataBuffer> getBody()

{
    return getDelegate().getBody();
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator

@Override public MultiValueMap<String, HttpCookie> getCookies()

{
    return getDelegate().getCookies();
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator

public ServerHttpRequest getDelegate()

{
    return this.delegate;
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator

@Override public HttpHeaders getHeaders()

{
    return getDelegate().getHeaders();
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator

@Override public String getId()

{
    return getDelegate().getId();
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator

@Override @Nullable public HttpMethod getMethod()

{
    return getDelegate().getMethod();
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator

@Override public String getMethodValue()

{
    return getDelegate().getMethodValue();
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator

@Override public RequestPath getPath()

{
    return getDelegate().getPath();
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator

@Override public MultiValueMap<String, String> getQueryParams()

{
    return getDelegate().getQueryParams();
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator

@Override public InetSocketAddress getRemoteAddress()

{
    return getDelegate().getRemoteAddress();
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator

@Nullable @Override public SslInfo getSslInfo()

{
    return getDelegate().getSslInfo();
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator

@Override public URI getURI()

{
    return getDelegate().getURI();
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator

@Override public String toString()

{
    return getClass().getSimpleName() + " [delegate=" + getDelegate() + "]";
}

ServerHttpResponse
inherit classes
  • ReactiveHttpOutputMessage

ServerHttpResponseDecorator
implements ServerHttpResponse

org.springframework.http.server.reactive.ServerHttpResponseDecorator

public ServerHttpResponseDecorator ServerHttpResponseDecorator(ServerHttpResponse delegate)

{
    Assert.notNull(delegate, "Delegate is required");
    this.delegate = delegate;
}
org.springframework.http.server.reactive.ServerHttpResponseDecorator

@Override public void beforeCommit(Supplier<?> action)

{
    getDelegate().beforeCommit(action);
}
org.springframework.http.server.reactive.ServerHttpResponseDecorator

@Override public DataBufferFactory bufferFactory()

{
    return getDelegate().bufferFactory();
}
org.springframework.http.server.reactive.ServerHttpResponseDecorator

@Override public MultiValueMap<String, ResponseCookie> getCookies()

{
    return getDelegate().getCookies();
}
org.springframework.http.server.reactive.ServerHttpResponseDecorator

public ServerHttpResponse getDelegate()

{
    return this.delegate;
}
org.springframework.http.server.reactive.ServerHttpResponseDecorator

@Override public HttpHeaders getHeaders()

{
    return getDelegate().getHeaders();
}
org.springframework.http.server.reactive.ServerHttpResponseDecorator

@Override public HttpStatus getStatusCode()

{
    return getDelegate().getStatusCode();
}
org.springframework.http.server.reactive.ServerHttpResponseDecorator

@Override public boolean isCommitted()

{
    return getDelegate().isCommitted();
}
org.springframework.http.server.reactive.ServerHttpResponseDecorator

@Override public Mono<Void> setComplete()

{
    return getDelegate().setComplete();
}
org.springframework.http.server.reactive.ServerHttpResponseDecorator

@Override public boolean setStatusCode(@Nullable HttpStatus status)

{
    return getDelegate().setStatusCode(status);
}
org.springframework.http.server.reactive.ServerHttpResponseDecorator

@Override public String toString()

{
    return getClass().getSimpleName() + " [delegate=" + getDelegate() + "]";
}
org.springframework.http.server.reactive.ServerHttpResponseDecorator

@Override public Mono<Void> writeAndFlushWith(Publisher<?> body)

{
    return getDelegate().writeAndFlushWith(body);
}
org.springframework.http.server.reactive.ServerHttpResponseDecorator

@Override public Mono<Void> writeWith(Publisher<?> body)

{
    return getDelegate().writeWith(body);
}

ServletHttpHandlerAdapter
implements Servlet

org.springframework.http.server.reactive.ServletHttpHandlerAdapter

public ServletHttpHandlerAdapter ServletHttpHandlerAdapter(HttpHandler httpHandler)

{
    Assert.notNull(httpHandler, "HttpHandler must not be null");
    this.httpHandler = httpHandler;
}
org.springframework.http.server.reactive.ServletHttpHandlerAdapter

protected ServletServerHttpRequest createRequest(HttpServletRequest request, AsyncContext context)

{
    Assert.notNull(this.servletPath, "Servlet path is not initialized");
    return new ServletServerHttpRequest(request, context, this.servletPath, getDataBufferFactory(), getBufferSize());
}
org.springframework.http.server.reactive.ServletHttpHandlerAdapter

protected ServletServerHttpResponse createResponse(HttpServletResponse response, AsyncContext context, ServletServerHttpRequest request)

{
    return new ServletServerHttpResponse(response, context, getDataBufferFactory(), getBufferSize(), request);
}
org.springframework.http.server.reactive.ServletHttpHandlerAdapter

@Override public void destroy()

{
}
org.springframework.http.server.reactive.ServletHttpHandlerAdapter

public int getBufferSize()

{
    return this.bufferSize;
}
org.springframework.http.server.reactive.ServletHttpHandlerAdapter

public DataBufferFactory getDataBufferFactory()

{
    return this.dataBufferFactory;
}
org.springframework.http.server.reactive.ServletHttpHandlerAdapter

@Override @Nullable public ServletConfig getServletConfig()

{
    return null;
}
org.springframework.http.server.reactive.ServletHttpHandlerAdapter

@Override public String getServletInfo()

{
    return "";
}
org.springframework.http.server.reactive.ServletHttpHandlerAdapter

@Nullable public String getServletPath()

{
    return this.servletPath;
}
org.springframework.http.server.reactive.ServletHttpHandlerAdapter

@Override public void init(ServletConfig config)

{
    this.servletPath = getServletPath(config);
}
org.springframework.http.server.reactive.ServletHttpHandlerAdapter

@Override public void service(ServletRequest request, ServletResponse response)

{
    if (DispatcherType.ASYNC.equals(request.getDispatcherType())) {
        Throwable ex = (Throwable)request.getAttribute(WRITE_ERROR_ATTRIBUTE_NAME);
        throw new ServletException("Failed to create response content", ex);
    } 
    AsyncContext asyncContext = request.startAsync();
    asyncContext.setTimeout(-1);
    ServletServerHttpRequest httpRequest;
    try {
        httpRequest = createRequest(((HttpServletRequest)request), asyncContext);
    } catch (URISyntaxException ex) {
        if (logger.isDebugEnabled()) {
            logger.debug("Failed to get request  URL: " + ex.getMessage());
        } 
        ((HttpServletResponse)response).setStatus(400);
        asyncContext.complete();
        return ;
    }
    ServerHttpResponse httpResponse = createResponse(((HttpServletResponse)response), asyncContext, httpRequest);
    if (httpRequest.getMethod() == HttpMethod.HEAD) {
        httpResponse = new HttpHeadResponseDecorator(httpResponse);
    } 
    AtomicBoolean isCompleted = new AtomicBoolean();
    HandlerResultAsyncListener listener = new HandlerResultAsyncListener(isCompleted, httpRequest);
    asyncContext.addListener(listener);
    HandlerResultSubscriber subscriber = new HandlerResultSubscriber(asyncContext, isCompleted, httpRequest);
    this.httpHandler.handle(httpRequest, httpResponse).subscribe(subscriber);
}
org.springframework.http.server.reactive.ServletHttpHandlerAdapter

public void setBufferSize(int bufferSize)

{
    Assert.isTrue(bufferSize > 0, "Buffer size must be larger than zero");
    this.bufferSize = bufferSize;
}
org.springframework.http.server.reactive.ServletHttpHandlerAdapter

public void setDataBufferFactory(DataBufferFactory dataBufferFactory)

{
    Assert.notNull(dataBufferFactory, "DataBufferFactory must not be null");
    this.dataBufferFactory = dataBufferFactory;
}

ServletServerHttpRequest
extends AbstractServerHttpRequest

org.springframework.http.server.reactive.ServletServerHttpRequest

public ServletServerHttpRequest ServletServerHttpRequest(HttpServletRequest request, AsyncContext asyncContext, String servletPath, DataBufferFactory bufferFactory, int bufferSize)

{
    this(createDefaultHttpHeaders(request), request, asyncContext, servletPath, bufferFactory, bufferSize);
}
org.springframework.http.server.reactive.ServletServerHttpRequest

@Override public Flux<DataBuffer> getBody()

{
    return Flux.from(this.bodyPublisher);
}
org.springframework.http.server.reactive.ServletServerHttpRequest

@Override public String getMethodValue()

{
    return this.request.getMethod();
}
org.springframework.http.server.reactive.ServletServerHttpRequest

<T>@SuppressWarnings("unchecked") @Override public T getNativeRequest()

{
    return (T)this.request;
}
org.springframework.http.server.reactive.ServletServerHttpRequest

@Override public InetSocketAddress getRemoteAddress()

{
    return new InetSocketAddress(this.request.getRemoteHost(), this.request.getRemotePort());
}
org.springframework.http.server.reactive.ServletServerHttpRequest

@Override @Nullable protected SslInfo initSslInfo()

{
    X509Certificate[] certificates = getX509Certificates();
    return certificates != null ? new DefaultSslInfo(getSslSessionId(), certificates) : null;
}

ServletServerHttpResponse
extends AbstractListenerServerHttpResponse

org.springframework.http.server.reactive.ServletServerHttpResponse

public ServletServerHttpResponse ServletServerHttpResponse(HttpServletResponse response, AsyncContext asyncContext, DataBufferFactory bufferFactory, int bufferSize, ServletServerHttpRequest request)

{
    this(new HttpHeaders(), response, asyncContext, bufferFactory, bufferSize, request);
}
org.springframework.http.server.reactive.ServletServerHttpResponse

@Override protected void applyHeaders()

{
    getHeaders().forEach((headerName, headerValues) -> {
        for (String headerValue: headerValues) {
            this.response.addHeader(headerName, headerValue);
        }
    });
    MediaType contentType = null;
    try {
        contentType = getHeaders().getContentType();
    } catch (Exception ex) {
        String rawContentType = getHeaders().getFirst(HttpHeaders.CONTENT_TYPE);
        this.response.setContentType(rawContentType);
    }
    if (this.response.getContentType() == null && contentType != null) {
        this.response.setContentType(contentType.toString());
    } 
    Charset charset = (contentType != null ? contentType.getCharset() : null);
    if (this.response.getCharacterEncoding() == null && charset != null) {
        this.response.setCharacterEncoding(charset.name());
    } 
    long contentLength = getHeaders().getContentLength();
    if (contentLength != -1) {
        this.response.setContentLengthLong(contentLength);
    } 
}
org.springframework.http.server.reactive.ServletServerHttpResponse

@Override protected void applyStatusCode()

{
    Integer statusCode = getStatusCodeValue();
    if (statusCode != null) {
        this.response.setStatus(statusCode);
    } 
}
org.springframework.http.server.reactive.ServletServerHttpResponse

@Nullable volatile ResponseBodyFlushProcessor bodyFlushProcessor

org.springframework.http.server.reactive.ServletServerHttpResponse

@Nullable volatile ResponseBodyProcessor bodyProcessor

org.springframework.http.server.reactive.ServletServerHttpResponse

@Override protected Processor<?, Void> createBodyFlushProcessor()

{
    ResponseBodyFlushProcessor processor = new ResponseBodyFlushProcessor();
    this.bodyFlushProcessor = processor;
    return processor;
}
org.springframework.http.server.reactive.ServletServerHttpResponse

volatile boolean flushOnNext

org.springframework.http.server.reactive.ServletServerHttpResponse

<T>@SuppressWarnings("unchecked") @Override public T getNativeResponse()

{
    return (T)this.response;
}
org.springframework.http.server.reactive.ServletServerHttpResponse

@Override public HttpStatus getStatusCode()

{
    HttpStatus httpStatus = super.getStatusCode();
    return (httpStatus != null ? httpStatus : HttpStatus.resolve(this.response.getStatus()));
}

SslInfo

TomcatHeadersAdapter
implements MultiValueMap<String, String>

org.springframework.http.server.reactive.TomcatHeadersAdapter

@Override public void add(String key, @Nullable String value)

{
    this.headers.addValue(key).setString(value);
}
org.springframework.http.server.reactive.TomcatHeadersAdapter

@Override public void addAll(String key, List<?> values)

{
    values.forEach(value -> add(key, value));
}
org.springframework.http.server.reactive.TomcatHeadersAdapter

@Override public void addAll(MultiValueMap<String, String> values)

{
    values.forEach(this::addAll);
}
org.springframework.http.server.reactive.TomcatHeadersAdapter

@Override public void clear()

{
    this.headers.clear();
}
org.springframework.http.server.reactive.TomcatHeadersAdapter

@Override public boolean containsKey(Object key)

{
    if (key instanceof String) {
        return (this.headers.findHeader((String)key, 0) != -1);
    } 
    return false;
}
org.springframework.http.server.reactive.TomcatHeadersAdapter

@Override public Set<Entry<String, List<String>>> entrySet()

{
    return new AbstractSet<Entry<String, List<String>>>() {
        @Override
        public Iterator<Entry<String, List<String>>> iterator() {
            return new EntryIterator();
        }
        @Override
        public int size() {
            return headers.size();
        }
    };
}
org.springframework.http.server.reactive.TomcatHeadersAdapter

@Override @Nullable public List<String> get(Object key)

{
    if (containsKey(key)) {
        return Collections.list(this.headers.values((String)key));
    } 
    return null;
}
org.springframework.http.server.reactive.TomcatHeadersAdapter

@Override public String getFirst(String key)

{
    return this.headers.getHeader(key);
}
org.springframework.http.server.reactive.TomcatHeadersAdapter

@Override public boolean isEmpty()

{
    return (this.headers.size() == 0);
}
org.springframework.http.server.reactive.TomcatHeadersAdapter

@Override public Set<String> keySet()

{
    Set<String> result = new HashSet<>(8);
    Enumeration<String> names = this.headers.names();
    while (names.hasMoreElements()) {
        result.add(names.nextElement());
    }
    return result;
}
org.springframework.http.server.reactive.TomcatHeadersAdapter

@Override @Nullable public List<String> put(String key, List<String> value)

{
    List<String> previousValues = get(key);
    this.headers.removeHeader(key);
    value.forEach(v -> this.headers.addValue(key).setString(v));
    return previousValues;
}
org.springframework.http.server.reactive.TomcatHeadersAdapter

@Override public void putAll(Map<?, ?> map)

{
    map.forEach(this::put);
}
org.springframework.http.server.reactive.TomcatHeadersAdapter

@Override @Nullable public List<String> remove(Object key)

{
    if (key instanceof String) {
        List<String> previousValues = get(key);
        this.headers.removeHeader((String)key);
        return previousValues;
    } 
    return null;
}
org.springframework.http.server.reactive.TomcatHeadersAdapter

@Override public void set(String key, @Nullable String value)

{
    this.headers.setValue(key).setString(value);
}
org.springframework.http.server.reactive.TomcatHeadersAdapter

@Override public void setAll(Map<String, String> values)

{
    values.forEach(this::set);
}
org.springframework.http.server.reactive.TomcatHeadersAdapter

@Override public int size()

{
    Enumeration<String> names = this.headers.names();
    int size = 0;
    while (names.hasMoreElements()) {
        size++;
        names.nextElement();
    }
    return size;
}
org.springframework.http.server.reactive.TomcatHeadersAdapter

@Override public String toString()

{
    return HttpHeaders.formatHeaders(this);
}
org.springframework.http.server.reactive.TomcatHeadersAdapter

@Override public Collection<List<String>> values()

{
    return keySet().stream().map(this::get).collect(Collectors.toList());
}

TomcatHttpHandlerAdapter
extends ServletHttpHandlerAdapter

org.springframework.http.server.reactive.TomcatHttpHandlerAdapter

public TomcatHttpHandlerAdapter TomcatHttpHandlerAdapter(HttpHandler httpHandler)

{
    super(httpHandler);
}
org.springframework.http.server.reactive.TomcatHttpHandlerAdapter

@Override protected ServletServerHttpRequest createRequest(HttpServletRequest request, AsyncContext asyncContext)

{
    Assert.notNull(getServletPath(), "Servlet path is not initialized");
    return new TomcatServerHttpRequest(request, asyncContext, getServletPath(), getDataBufferFactory(), getBufferSize());
}
org.springframework.http.server.reactive.TomcatHttpHandlerAdapter

@Override protected ServletServerHttpResponse createResponse(HttpServletResponse response, AsyncContext asyncContext, ServletServerHttpRequest request)

{
    return new TomcatServerHttpResponse(response, asyncContext, getDataBufferFactory(), getBufferSize(), request);
}

UndertowHeadersAdapter
implements MultiValueMap<String, String>

org.springframework.http.server.reactive.UndertowHeadersAdapter

@Override public void add(String key, @Nullable String value)

{
    this.headers.add(HttpString.tryFromString(key), value);
}
org.springframework.http.server.reactive.UndertowHeadersAdapter

@Override @SuppressWarnings("unchecked") public void addAll(String key, List<?> values)

{
    this.headers.addAll(HttpString.tryFromString(key), (List<String>)values);
}
org.springframework.http.server.reactive.UndertowHeadersAdapter

@Override public void addAll(MultiValueMap<String, String> values)

{
    values.forEach((key, list) -> this.headers.addAll(HttpString.tryFromString(key), list));
}
org.springframework.http.server.reactive.UndertowHeadersAdapter

@Override public void clear()

{
    this.headers.clear();
}
org.springframework.http.server.reactive.UndertowHeadersAdapter

@Override public boolean containsKey(Object key)

{
    return (key instanceof String && this.headers.contains((String)key));
}
org.springframework.http.server.reactive.UndertowHeadersAdapter

@Override public boolean containsValue(Object value)

{
    return (value instanceof String && this.headers.getHeaderNames().stream().map(this.headers::get).anyMatch(values -> values.contains(value)));
}
org.springframework.http.server.reactive.UndertowHeadersAdapter

@Override public Set<Entry<String, List<String>>> entrySet()

{
    return new AbstractSet<Entry<String, List<String>>>() {
        @Override
        public Iterator<Entry<String, List<String>>> iterator() {
            return new EntryIterator();
        }
        @Override
        public int size() {
            return headers.size();
        }
    };
}
org.springframework.http.server.reactive.UndertowHeadersAdapter

@Override @Nullable public List<String> get(Object key)

{
    if (key instanceof String) {
        return this.headers.get((String)key);
    } 
    return null;
}
org.springframework.http.server.reactive.UndertowHeadersAdapter

@Override public String getFirst(String key)

{
    return this.headers.getFirst(key);
}
org.springframework.http.server.reactive.UndertowHeadersAdapter

@Override public boolean isEmpty()

{
    return (this.headers.size() == 0);
}
org.springframework.http.server.reactive.UndertowHeadersAdapter

@Override public Set<String> keySet()

{
    return this.headers.getHeaderNames().stream().map(HttpString::toString).collect(Collectors.toSet());
}
org.springframework.http.server.reactive.UndertowHeadersAdapter

@Override @Nullable public List<String> put(String key, List<String> value)

{
    HeaderValues previousValues = this.headers.get(key);
    this.headers.putAll(HttpString.tryFromString(key), value);
    return previousValues;
}
org.springframework.http.server.reactive.UndertowHeadersAdapter

@Override public void putAll(Map<?, ?> map)

{
    map.forEach((key, values) -> this.headers.putAll(HttpString.tryFromString(key), values));
}
org.springframework.http.server.reactive.UndertowHeadersAdapter

@Override @Nullable public List<String> remove(Object key)

{
    if (key instanceof String) {
        this.headers.remove((String)key);
    } 
    return null;
}
org.springframework.http.server.reactive.UndertowHeadersAdapter

@Override public void set(String key, @Nullable String value)

{
    this.headers.put(HttpString.tryFromString(key), value);
}
org.springframework.http.server.reactive.UndertowHeadersAdapter

@Override public void setAll(Map<String, String> values)

{
    values.forEach((key, list) -> this.headers.put(HttpString.tryFromString(key), list));
}
org.springframework.http.server.reactive.UndertowHeadersAdapter

@Override public int size()

{
    return this.headers.size();
}
org.springframework.http.server.reactive.UndertowHeadersAdapter

@Override public String toString()

{
    return org.springframework.http.HttpHeaders.formatHeaders(this);
}
org.springframework.http.server.reactive.UndertowHeadersAdapter

@Override public Collection<List<String>> values()

{
    return this.headers.getHeaderNames().stream().map(this.headers::get).collect(Collectors.toList());
}

UndertowHttpHandlerAdapter
implements io.undertow.server.HttpHandler

org.springframework.http.server.reactive.UndertowHttpHandlerAdapter

public UndertowHttpHandlerAdapter UndertowHttpHandlerAdapter(HttpHandler httpHandler)

{
    Assert.notNull(httpHandler, "HttpHandler must not be null");
    this.httpHandler = httpHandler;
}
org.springframework.http.server.reactive.UndertowHttpHandlerAdapter

public DataBufferFactory getDataBufferFactory()

{
    return this.bufferFactory;
}
org.springframework.http.server.reactive.UndertowHttpHandlerAdapter

@Override public void handleRequest(HttpServerExchange exchange)

{
    UndertowServerHttpRequest request = null;
    try {
        request = new UndertowServerHttpRequest(exchange, getDataBufferFactory());
    } catch (URISyntaxException ex) {
        if (logger.isWarnEnabled()) {
            logger.debug("Failed to get request URI: " + ex.getMessage());
        } 
        exchange.setStatusCode(400);
        return ;
    }
    ServerHttpResponse response = new UndertowServerHttpResponse(exchange, getDataBufferFactory(), request);
    if (request.getMethod() == HttpMethod.HEAD) {
        response = new HttpHeadResponseDecorator(response);
    } 
    HandlerResultSubscriber resultSubscriber = new HandlerResultSubscriber(exchange, request);
    this.httpHandler.handle(request, response).subscribe(resultSubscriber);
}
org.springframework.http.server.reactive.UndertowHttpHandlerAdapter

public void setDataBufferFactory(DataBufferFactory bufferFactory)

{
    Assert.notNull(bufferFactory, "DataBufferFactory must not be null");
    this.bufferFactory = bufferFactory;
}

UndertowServerHttpRequest
extends AbstractServerHttpRequest

org.springframework.http.server.reactive.UndertowServerHttpRequest

public UndertowServerHttpRequest UndertowServerHttpRequest(HttpServerExchange exchange, DataBufferFactory bufferFactory)

{
    super(initUri(exchange), "", initHeaders(exchange));
    this.exchange = exchange;
    this.body = new RequestBodyPublisher(exchange, bufferFactory);
    this.body.registerListeners(exchange);
}
org.springframework.http.server.reactive.UndertowServerHttpRequest

@Override public Flux<DataBuffer> getBody()

{
    return Flux.from(this.body);
}
org.springframework.http.server.reactive.UndertowServerHttpRequest

@Override public String getMethodValue()

{
    return this.exchange.getRequestMethod().toString();
}
org.springframework.http.server.reactive.UndertowServerHttpRequest

<T>@SuppressWarnings("unchecked") @Override public T getNativeRequest()

{
    return (T)this.exchange;
}
org.springframework.http.server.reactive.UndertowServerHttpRequest

@Override public InetSocketAddress getRemoteAddress()

{
    return this.exchange.getSourceAddress();
}
org.springframework.http.server.reactive.UndertowServerHttpRequest

@Override protected String initId()

{
    return ObjectUtils.getIdentityHexString(this.exchange.getConnection());
}
org.springframework.http.server.reactive.UndertowServerHttpRequest

@Nullable @Override protected SslInfo initSslInfo()

{
    SSLSession session = this.exchange.getConnection().getSslSession();
    if (session != null) {
        return new DefaultSslInfo(session);
    } 
    return null;
}

UndertowServerHttpResponse
extends AbstractListenerServerHttpResponse implements ZeroCopyHttpOutputMessage

org.springframework.http.server.reactive.UndertowServerHttpResponse

@Override protected void applyCookies()

{
    for (String name: getCookies().keySet()) {
        for (ResponseCookie httpCookie: getCookies().get(name)) {
            Cookie cookie = new CookieImpl(name, httpCookie.getValue());
            if (!httpCookie.getMaxAge().isNegative()) {
                cookie.setMaxAge((int)httpCookie.getMaxAge().getSeconds());
            } 
            if (httpCookie.getDomain() != null) {
                cookie.setDomain(httpCookie.getDomain());
            } 
            if (httpCookie.getPath() != null) {
                cookie.setPath(httpCookie.getPath());
            } 
            cookie.setSecure(httpCookie.isSecure());
            cookie.setHttpOnly(httpCookie.isHttpOnly());
            cookie.setSameSiteMode(httpCookie.getSameSite());
            this.exchange.getResponseCookies().putIfAbsent(name, cookie);
        }
    }
}
org.springframework.http.server.reactive.UndertowServerHttpResponse

@Override protected void applyHeaders()

{
}
org.springframework.http.server.reactive.UndertowServerHttpResponse

@Override protected void applyStatusCode()

{
    Integer statusCode = getStatusCodeValue();
    if (statusCode != null) {
        this.exchange.setStatusCode(statusCode);
    } 
}
org.springframework.http.server.reactive.UndertowServerHttpResponse

@Override protected Processor<?, Void> createBodyFlushProcessor()

{
    return new ResponseBodyFlushProcessor();
}
org.springframework.http.server.reactive.UndertowServerHttpResponse

<T>@SuppressWarnings("unchecked") @Override public T getNativeResponse()

{
    return (T)this.exchange;
}
org.springframework.http.server.reactive.UndertowServerHttpResponse

@Override public HttpStatus getStatusCode()

{
    HttpStatus httpStatus = super.getStatusCode();
    return (httpStatus != null ? httpStatus : HttpStatus.resolve(this.exchange.getStatusCode()));
}

WriteResultPublisher
implements Publisher<Void>

org.springframework.http.server.reactive.WriteResultPublisher

public WriteResultPublisher WriteResultPublisher(String logPrefix)

{
    this.logPrefix = logPrefix;
}
org.springframework.http.server.reactive.WriteResultPublisher

volatile boolean completedBeforeSubscribed

org.springframework.http.server.reactive.WriteResultPublisher

@Nullable volatile Throwable errorBeforeSubscribed

org.springframework.http.server.reactive.WriteResultPublisher

public void publishComplete()

{
    if (rsWriteResultLogger.isTraceEnabled()) {
        rsWriteResultLogger.trace(this.logPrefix + this.state + " publishComplete");
    } 
    this.state.get().publishComplete(this);
}
org.springframework.http.server.reactive.WriteResultPublisher

public void publishError(Throwable t)

{
    if (rsWriteResultLogger.isTraceEnabled()) {
        rsWriteResultLogger.trace(this.logPrefix + this.state + " publishError: " + t);
    } 
    this.state.get().publishError(this, t);
}
org.springframework.http.server.reactive.WriteResultPublisher

@Override public final void subscribe(Subscriber<?> subscriber)

{
    if (rsWriteResultLogger.isTraceEnabled()) {
        rsWriteResultLogger.trace(this.logPrefix + this.state + " subscribe: " + subscriber);
    } 
    this.state.get().subscribe(this, subscriber);
}
org.springframework.http.server.reactive.WriteResultPublisher

@Nullable volatile Subscriber<?> subscriber



HessianClientInterceptor
extends UrlBasedRemoteAccessor implements MethodInterceptor

org.springframework.remoting.caucho.HessianClientInterceptor

@Override public void afterPropertiesSet()

{
    super.afterPropertiesSet();
    prepare();
}
org.springframework.remoting.caucho.HessianClientInterceptor

protected Object createHessianProxy(HessianProxyFactory proxyFactory)

{
    Assert.notNull(getServiceInterface(), "'serviceInterface' is required");
    return proxyFactory.create(getServiceInterface(), getServiceUrl(), getBeanClassLoader());
}
org.springframework.remoting.caucho.HessianClientInterceptor

public void prepare()

{
    try {
        this.hessianProxy = createHessianProxy(this.proxyFactory);
    } catch (MalformedURLException ex) {
        throw new RemoteLookupFailureException("Service URL [" + getServiceUrl() + "] is invalid", ex);
    }
}
org.springframework.remoting.caucho.HessianClientInterceptor

public void setAllowNonSerializable(boolean allowNonSerializable)

{
    this.proxyFactory.getSerializerFactory().setAllowNonSerializable(allowNonSerializable);
}
org.springframework.remoting.caucho.HessianClientInterceptor

public void setChunkedPost(boolean chunkedPost)

{
    this.proxyFactory.setChunkedPost(chunkedPost);
}
org.springframework.remoting.caucho.HessianClientInterceptor

public void setConnectTimeout(long timeout)

{
    this.proxyFactory.setConnectTimeout(timeout);
}
org.springframework.remoting.caucho.HessianClientInterceptor

public void setConnectionFactory(HessianConnectionFactory connectionFactory)

{
    this.proxyFactory.setConnectionFactory(connectionFactory);
}
org.springframework.remoting.caucho.HessianClientInterceptor

public void setDebug(boolean debug)

{
    this.proxyFactory.setDebug(debug);
}
org.springframework.remoting.caucho.HessianClientInterceptor

public void setHessian2(boolean hessian2)

{
    this.proxyFactory.setHessian2Request(hessian2);
    this.proxyFactory.setHessian2Reply(hessian2);
}
org.springframework.remoting.caucho.HessianClientInterceptor

public void setHessian2Reply(boolean hessian2)

{
    this.proxyFactory.setHessian2Reply(hessian2);
}
org.springframework.remoting.caucho.HessianClientInterceptor

public void setHessian2Request(boolean hessian2)

{
    this.proxyFactory.setHessian2Request(hessian2);
}
org.springframework.remoting.caucho.HessianClientInterceptor

public void setOverloadEnabled(boolean overloadEnabled)

{
    this.proxyFactory.setOverloadEnabled(overloadEnabled);
}
org.springframework.remoting.caucho.HessianClientInterceptor

public void setPassword(String password)

{
    this.proxyFactory.setPassword(password);
}
org.springframework.remoting.caucho.HessianClientInterceptor

public void setProxyFactory(@Nullable HessianProxyFactory proxyFactory)

{
    this.proxyFactory = (proxyFactory != null ? proxyFactory : new HessianProxyFactory());
}
org.springframework.remoting.caucho.HessianClientInterceptor

public void setReadTimeout(long timeout)

{
    this.proxyFactory.setReadTimeout(timeout);
}
org.springframework.remoting.caucho.HessianClientInterceptor

public void setSendCollectionType(boolean sendCollectionType)

{
    this.proxyFactory.getSerializerFactory().setSendCollectionType(sendCollectionType);
}
org.springframework.remoting.caucho.HessianClientInterceptor

public void setSerializerFactory(SerializerFactory serializerFactory)

{
    this.proxyFactory.setSerializerFactory(serializerFactory);
}
org.springframework.remoting.caucho.HessianClientInterceptor

public void setUsername(String username)

{
    this.proxyFactory.setUser(username);
}

HessianExporter
extends RemoteExporter implements InitializingBean

org.springframework.remoting.caucho.HessianExporter

public static final String CONTENT_TYPE_HESSIAN

org.springframework.remoting.caucho.HessianExporter

@Override public void afterPropertiesSet()

{
    prepare();
}
org.springframework.remoting.caucho.HessianExporter

protected void doInvoke(HessianSkeleton skeleton, InputStream inputStream, OutputStream outputStream)

{
    ClassLoader originalClassLoader = overrideThreadContextClassLoader();
    try {
        InputStream isToUse = inputStream;
        OutputStream osToUse = outputStream;
        if (this.debugLogger != null && this.debugLogger.isDebugEnabled()) {
            try (PrintWriter debugWriter = new PrintWriter(new CommonsLogWriter(this.debugLogger))){
                @SuppressWarnings("resource") HessianDebugInputStream dis = new HessianDebugInputStream(inputStream, debugWriter);
                @SuppressWarnings("resource") HessianDebugOutputStream dos = new HessianDebugOutputStream(outputStream, debugWriter);
                dis.startTop2();
                dos.startTop2();
                isToUse = dis;
                osToUse = dos;
            }
        } 
        if (!isToUse.markSupported()) {
            isToUse = new BufferedInputStream(isToUse);
            isToUse.mark(1);
        } 
        int code = isToUse.read();
        int major;
        int minor;
        AbstractHessianInput in;
        AbstractHessianOutput out;
        if (code == 'H') {
            major = isToUse.read();
            minor = isToUse.read();
            if (major != 0x02) {
                throw new IOException("Version " + major + '.' + minor + " is not understood");
            } 
            in = new Hessian2Input(isToUse);
            out = new Hessian2Output(osToUse);
            in.readCall();
        } else if (code == 'C') {
            isToUse.reset();
            in = new Hessian2Input(isToUse);
            out = new Hessian2Output(osToUse);
            in.readCall();
        } else if (code == 'c') {
            major = isToUse.read();
            minor = isToUse.read();
            in = new HessianInput(isToUse);
            if (major >= 2) {
                out = new Hessian2Output(osToUse);
            } else {
                out = new HessianOutput(osToUse);
            }
        } else {
            throw new IOException("Expected 'H'/'C' (Hessian 2.0) or 'c' (Hessian 1.0) in hessian input at " + code);
        }
        in.setSerializerFactory(this.serializerFactory);
        out.setSerializerFactory(this.serializerFactory);
        if (this.remoteResolver != null) {
            in.setRemoteResolver(this.remoteResolver);
        } 
        try {
            skeleton.invoke(in, out);
        } finally {
            try {
                in.close();
                isToUse.close();
            } catch (IOException ex) {
            }
            try {
                out.close();
                osToUse.close();
            } catch (IOException ex) {
            }
        }
    } finally {
        resetThreadContextClassLoader(originalClassLoader);
    }
}
org.springframework.remoting.caucho.HessianExporter

public void invoke(InputStream inputStream, OutputStream outputStream)

{
    Assert.notNull(this.skeleton, "Hessian exporter has not been initialized");
    doInvoke(this.skeleton, inputStream, outputStream);
}
org.springframework.remoting.caucho.HessianExporter

public void setAllowNonSerializable(boolean allowNonSerializable)

{
    this.serializerFactory.setAllowNonSerializable(allowNonSerializable);
}
org.springframework.remoting.caucho.HessianExporter

public void setDebug(boolean debug)

{
    this.debugLogger = (debug ? logger : null);
}
org.springframework.remoting.caucho.HessianExporter

public void setRemoteResolver(HessianRemoteResolver remoteResolver)

{
    this.remoteResolver = remoteResolver;
}
org.springframework.remoting.caucho.HessianExporter

public void setSendCollectionType(boolean sendCollectionType)

{
    this.serializerFactory.setSendCollectionType(sendCollectionType);
}
org.springframework.remoting.caucho.HessianExporter

public void setSerializerFactory(@Nullable SerializerFactory serializerFactory)

{
    this.serializerFactory = (serializerFactory != null ? serializerFactory : new SerializerFactory());
}

HessianProxyFactoryBean
extends HessianClientInterceptor implements FactoryBean<Object>

org.springframework.remoting.caucho.HessianProxyFactoryBean

@Override public void afterPropertiesSet()

{
    super.afterPropertiesSet();
    this.serviceProxy = new ProxyFactory(getServiceInterface(), this).getProxy(getBeanClassLoader());
}
org.springframework.remoting.caucho.HessianProxyFactoryBean

@Override @Nullable public Object getObject()

{
    return this.serviceProxy;
}
org.springframework.remoting.caucho.HessianProxyFactoryBean

@Override public Class<?> getObjectType()

{
    return getServiceInterface();
}
org.springframework.remoting.caucho.HessianProxyFactoryBean

@Override public boolean isSingleton()

{
    return true;
}

HessianServiceExporter
extends HessianExporter implements HttpRequestHandler

org.springframework.remoting.caucho.HessianServiceExporter

@Override public void handleRequest(HttpServletRequest request, HttpServletResponse response)

{
    if (!"POST".equals(request.getMethod())) {
        throw new HttpRequestMethodNotSupportedException(request.getMethod(), new String[]{"POST"}, "HessianServiceExporter only supports POST requests");
    } 
    response.setContentType(CONTENT_TYPE_HESSIAN);
    try {
        invoke(request.getInputStream(), response.getOutputStream());
    } catch (Throwable ex) {
        throw new NestedServletException("Hessian skeleton invocation failed", ex);
    }
}

SimpleHessianServiceExporter
extends HessianExporter implements HttpHandler

org.springframework.remoting.caucho.SimpleHessianServiceExporter

@Override public void handle(HttpExchange exchange)

{
    if (!"POST".equals(exchange.getRequestMethod())) {
        exchange.getResponseHeaders().set("Allow", "POST");
        exchange.sendResponseHeaders(405, -1);
        return ;
    } 
    ByteArrayOutputStream output = new ByteArrayOutputStream(1024);
    try {
        invoke(exchange.getRequestBody(), output);
    } catch (Throwable ex) {
        exchange.sendResponseHeaders(500, -1);
        logger.error("Hessian skeleton invocation failed", ex);
        return ;
    }
    exchange.getResponseHeaders().set("Content-Type", CONTENT_TYPE_HESSIAN);
    exchange.sendResponseHeaders(200, output.size());
    FileCopyUtils.copy(output.toByteArray(), exchange.getResponseBody());
}


AbstractHttpInvokerRequestExecutor
implements HttpInvokerRequestExecutor, BeanClassLoaderAware

org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

public static final String CONTENT_TYPE_SERIALIZED_OBJECT

org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

protected static final String ENCODING_GZIP

org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

protected static final String HTTP_HEADER_ACCEPT_ENCODING

org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

protected static final String HTTP_HEADER_ACCEPT_LANGUAGE

org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

protected static final String HTTP_HEADER_CONTENT_ENCODING

org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

protected static final String HTTP_HEADER_CONTENT_LENGTH

org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

protected static final String HTTP_HEADER_CONTENT_TYPE

org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

protected static final String HTTP_METHOD_POST

org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

protected ObjectInputStream createObjectInputStream(InputStream is, @Nullable String codebaseUrl)

{
    return new CodebaseAwareObjectInputStream(is, getBeanClassLoader(), codebaseUrl);
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

protected InputStream decorateInputStream(InputStream is)

{
    return is;
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

protected OutputStream decorateOutputStream(OutputStream os)

{
    return os;
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

protected abstract RemoteInvocationResult doExecuteRequest(HttpInvokerClientConfiguration config, ByteArrayOutputStream baos)

org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

protected RemoteInvocationResult doReadRemoteInvocationResult(ObjectInputStream ois)

{
    Object obj = ois.readObject();
    if (!(obj instanceof RemoteInvocationResult)) {
        throw new RemoteException("Deserialized object needs to be assignable to type [" + RemoteInvocationResult.class.getName() + "]: " + ClassUtils.getDescriptiveType(obj));
    } 
    return (RemoteInvocationResult)obj;
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

protected void doWriteRemoteInvocation(RemoteInvocation invocation, ObjectOutputStream oos)

{
    oos.writeObject(invocation);
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

@Override public final RemoteInvocationResult executeRequest(HttpInvokerClientConfiguration config, RemoteInvocation invocation)

{
    ByteArrayOutputStream baos = getByteArrayOutputStream(invocation);
    if (logger.isDebugEnabled()) {
        logger.debug("Sending HTTP invoker request for service at [" + config.getServiceUrl() + "], with size " + baos.size());
    } 
    return doExecuteRequest(config, baos);
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

@Nullable protected ClassLoader getBeanClassLoader()

{
    return this.beanClassLoader;
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

protected ByteArrayOutputStream getByteArrayOutputStream(RemoteInvocation invocation)

{
    ByteArrayOutputStream baos = new ByteArrayOutputStream(SERIALIZED_INVOCATION_BYTE_ARRAY_INITIAL_SIZE);
    writeRemoteInvocation(invocation, baos);
    return baos;
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

public String getContentType()

{
    return this.contentType;
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

public boolean isAcceptGzipEncoding()

{
    return this.acceptGzipEncoding;
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

protected final Log logger

org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

protected RemoteInvocationResult readRemoteInvocationResult(InputStream is, @Nullable String codebaseUrl)

{
    ObjectInputStream ois = createObjectInputStream(decorateInputStream(is), codebaseUrl);
    try {
        return doReadRemoteInvocationResult(ois);
    } finally {
        ois.close();
    }
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

public void setAcceptGzipEncoding(boolean acceptGzipEncoding)

{
    this.acceptGzipEncoding = acceptGzipEncoding;
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

@Override public void setBeanClassLoader(ClassLoader classLoader)

{
    this.beanClassLoader = classLoader;
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

public void setContentType(String contentType)

{
    Assert.notNull(contentType, "'contentType' must not be null");
    this.contentType = contentType;
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor

protected void writeRemoteInvocation(RemoteInvocation invocation, OutputStream os)

{
    ObjectOutputStream oos = new ObjectOutputStream(decorateOutputStream(os));
    try {
        doWriteRemoteInvocation(invocation, oos);
    } finally {
        oos.close();
    }
}

HttpComponentsHttpInvokerRequestExecutor
extends AbstractHttpInvokerRequestExecutor

org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor

public HttpComponentsHttpInvokerRequestExecutor HttpComponentsHttpInvokerRequestExecutor()

{
    this(createDefaultHttpClient(), RequestConfig.custom().setSocketTimeout(DEFAULT_READ_TIMEOUT_MILLISECONDS).build());
}
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor

public HttpComponentsHttpInvokerRequestExecutor HttpComponentsHttpInvokerRequestExecutor(HttpClient httpClient)

{
    this(httpClient, null);
}
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor

protected HttpPost createHttpPost(HttpInvokerClientConfiguration config)

{
    HttpPost httpPost = new HttpPost(config.getServiceUrl());
    RequestConfig requestConfig = createRequestConfig(config);
    if (requestConfig != null) {
        httpPost.setConfig(requestConfig);
    } 
    LocaleContext localeContext = LocaleContextHolder.getLocaleContext();
    if (localeContext != null) {
        Locale locale = localeContext.getLocale();
        if (locale != null) {
            httpPost.addHeader(HTTP_HEADER_ACCEPT_LANGUAGE, locale.toLanguageTag());
        } 
    } 
    if (isAcceptGzipEncoding()) {
        httpPost.addHeader(HTTP_HEADER_ACCEPT_ENCODING, ENCODING_GZIP);
    } 
    return httpPost;
}
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor

@Nullable protected RequestConfig createRequestConfig(HttpInvokerClientConfiguration config)

{
    HttpClient client = getHttpClient();
    if (client instanceof Configurable) {
        RequestConfig clientRequestConfig = ((Configurable)client).getConfig();
        return mergeRequestConfig(clientRequestConfig);
    } 
    return this.requestConfig;
}
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor

protected HttpResponse executeHttpPost(HttpInvokerClientConfiguration config, HttpClient httpClient, HttpPost httpPost)

{
    return httpClient.execute(httpPost);
}
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor

public HttpClient getHttpClient()

{
    return this.httpClient;
}
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor

protected InputStream getResponseBody(HttpInvokerClientConfiguration config, HttpResponse httpResponse)

{
    if (isGzipResponse(httpResponse)) {
        return new GZIPInputStream(httpResponse.getEntity().getContent());
    } else {
        return httpResponse.getEntity().getContent();
    }
}
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor

public void setConnectTimeout(int timeout)

{
    Assert.isTrue(timeout >= 0, "Timeout must be a non-negative value");
    this.requestConfig = cloneRequestConfig().setConnectTimeout(timeout).build();
}
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor

public void setConnectionRequestTimeout(int connectionRequestTimeout)

{
    this.requestConfig = cloneRequestConfig().setConnectionRequestTimeout(connectionRequestTimeout).build();
}
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor

public void setHttpClient(HttpClient httpClient)

{
    this.httpClient = httpClient;
}
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor

public void setReadTimeout(int timeout)

{
    Assert.isTrue(timeout >= 0, "Timeout must be a non-negative value");
    this.requestConfig = cloneRequestConfig().setSocketTimeout(timeout).build();
}
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor

protected void setRequestBody(HttpInvokerClientConfiguration config, HttpPost httpPost, ByteArrayOutputStream baos)

{
    ByteArrayEntity entity = new ByteArrayEntity(baos.toByteArray());
    entity.setContentType(getContentType());
    httpPost.setEntity(entity);
}
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor

protected void validateResponse(HttpInvokerClientConfiguration config, HttpResponse response)

{
    StatusLine status = response.getStatusLine();
    if (status.getStatusCode() >= 300) {
        throw new NoHttpResponseException("Did not receive successful HTTP response: status code = " + status.getStatusCode() + ", status message = [" + status.getReasonPhrase() + "]");
    } 
}

HttpInvokerClientConfiguration

HttpInvokerClientInterceptor
extends RemoteInvocationBasedAccessor implements MethodInterceptor, HttpInvokerClientConfiguration

org.springframework.remoting.httpinvoker.HttpInvokerClientInterceptor

@Override public void afterPropertiesSet()

{
    super.afterPropertiesSet();
    getHttpInvokerRequestExecutor();
}
org.springframework.remoting.httpinvoker.HttpInvokerClientInterceptor

@Nullable protected RemoteAccessException convertHttpInvokerAccessException(Throwable ex)

{
    if (ex instanceof ConnectException) {
        return new RemoteConnectFailureException("Could not connect to HTTP invoker remote service at [" + getServiceUrl() + "]", ex);
    } 
    if (ex instanceof ClassNotFoundException || ex instanceof NoClassDefFoundError || ex instanceof InvalidClassException) {
        return new RemoteAccessException("Could not deserialize result from HTTP invoker remote service [" + getServiceUrl() + "]", ex);
    } 
    if (ex instanceof Exception) {
        return new RemoteAccessException("Could not access HTTP invoker remote service at [" + getServiceUrl() + "]", ex);
    } 
    return null;
}
org.springframework.remoting.httpinvoker.HttpInvokerClientInterceptor

protected RemoteInvocationResult executeRequest(RemoteInvocation invocation, MethodInvocation originalInvocation)

{
    return executeRequest(invocation);
}
org.springframework.remoting.httpinvoker.HttpInvokerClientInterceptor

protected RemoteInvocationResult executeRequest(RemoteInvocation invocation)

{
    return getHttpInvokerRequestExecutor().executeRequest(this, invocation);
}
org.springframework.remoting.httpinvoker.HttpInvokerClientInterceptor

@Override @Nullable public String getCodebaseUrl()

{
    return this.codebaseUrl;
}
org.springframework.remoting.httpinvoker.HttpInvokerClientInterceptor

public HttpInvokerRequestExecutor getHttpInvokerRequestExecutor()

{
    if (this.httpInvokerRequestExecutor == null) {
        SimpleHttpInvokerRequestExecutor executor = new SimpleHttpInvokerRequestExecutor();
        executor.setBeanClassLoader(getBeanClassLoader());
        this.httpInvokerRequestExecutor = executor;
    } 
    return this.httpInvokerRequestExecutor;
}
org.springframework.remoting.httpinvoker.HttpInvokerClientInterceptor

public void setCodebaseUrl(@Nullable String codebaseUrl)

{
    this.codebaseUrl = codebaseUrl;
}
org.springframework.remoting.httpinvoker.HttpInvokerClientInterceptor

public void setHttpInvokerRequestExecutor(HttpInvokerRequestExecutor httpInvokerRequestExecutor)

{
    this.httpInvokerRequestExecutor = httpInvokerRequestExecutor;
}

HttpInvokerProxyFactoryBean
extends HttpInvokerClientInterceptor implements FactoryBean<Object>

org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean

@Override @Nullable public Object getObject()

{
    return this.serviceProxy;
}
org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean

@Override public Class<?> getObjectType()

{
    return getServiceInterface();
}
org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean

@Override public boolean isSingleton()

{
    return true;
}

HttpInvokerRequestExecutor

HttpInvokerServiceExporter
extends RemoteInvocationSerializingExporter implements HttpRequestHandler

org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter

protected InputStream decorateInputStream(HttpServletRequest request, InputStream is)

{
    return is;
}
org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter

protected OutputStream decorateOutputStream(HttpServletRequest request, HttpServletResponse response, OutputStream os)

{
    return os;
}
org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter

@Override public void handleRequest(HttpServletRequest request, HttpServletResponse response)

{
    try {
        RemoteInvocation invocation = readRemoteInvocation(request);
        RemoteInvocationResult result = invokeAndCreateResult(invocation, getProxy());
        writeRemoteInvocationResult(request, response, result);
    } catch (ClassNotFoundException ex) {
        throw new NestedServletException("Class not found during deserialization", ex);
    }
}
org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter

protected RemoteInvocation readRemoteInvocation(HttpServletRequest request)

{
    return readRemoteInvocation(request, request.getInputStream());
}
org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter

protected RemoteInvocation readRemoteInvocation(HttpServletRequest request, InputStream is)

{
    ObjectInputStream ois = createObjectInputStream(decorateInputStream(request, is));
    try {
        return doReadRemoteInvocation(ois);
    } finally {
        ois.close();
    }
}
org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter

protected void writeRemoteInvocationResult(HttpServletRequest request, HttpServletResponse response, RemoteInvocationResult result)

{
    response.setContentType(getContentType());
    writeRemoteInvocationResult(request, response, result, response.getOutputStream());
}
org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter

protected void writeRemoteInvocationResult(HttpServletRequest request, HttpServletResponse response, RemoteInvocationResult result, OutputStream os)

{
    ObjectOutputStream oos = createObjectOutputStream(new FlushGuardedOutputStream(decorateOutputStream(request, response, os)));
    try {
        doWriteRemoteInvocationResult(result, oos);
    } finally {
        oos.close();
    }
}

SimpleHttpInvokerRequestExecutor
extends AbstractHttpInvokerRequestExecutor

org.springframework.remoting.httpinvoker.SimpleHttpInvokerRequestExecutor

@Override protected RemoteInvocationResult doExecuteRequest(HttpInvokerClientConfiguration config, ByteArrayOutputStream baos)

{
    HttpURLConnection con = openConnection(config);
    prepareConnection(con, baos.size());
    writeRequestBody(config, con, baos);
    validateResponse(config, con);
    InputStream responseBody = readResponseBody(config, con);
    return readRemoteInvocationResult(responseBody, config.getCodebaseUrl());
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerRequestExecutor

protected boolean isGzipResponse(HttpURLConnection con)

{
    String encodingHeader = con.getHeaderField(HTTP_HEADER_CONTENT_ENCODING);
    return (encodingHeader != null && encodingHeader.toLowerCase().contains(ENCODING_GZIP));
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerRequestExecutor

protected HttpURLConnection openConnection(HttpInvokerClientConfiguration config)

{
    URLConnection con = new URL(config.getServiceUrl()).openConnection();
    if (!(con instanceof HttpURLConnection)) {
        throw new IOException("Service URL [" + config.getServiceUrl() + "] does not resolve to an HTTP connection");
    } 
    return (HttpURLConnection)con;
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerRequestExecutor

protected void prepareConnection(HttpURLConnection connection, int contentLength)

{
    if (this.connectTimeout >= 0) {
        connection.setConnectTimeout(this.connectTimeout);
    } 
    if (this.readTimeout >= 0) {
        connection.setReadTimeout(this.readTimeout);
    } 
    connection.setDoOutput(true);
    connection.setRequestMethod(HTTP_METHOD_POST);
    connection.setRequestProperty(HTTP_HEADER_CONTENT_TYPE, getContentType());
    connection.setRequestProperty(HTTP_HEADER_CONTENT_LENGTH, Integer.toString(contentLength));
    LocaleContext localeContext = LocaleContextHolder.getLocaleContext();
    if (localeContext != null) {
        Locale locale = localeContext.getLocale();
        if (locale != null) {
            connection.setRequestProperty(HTTP_HEADER_ACCEPT_LANGUAGE, locale.toLanguageTag());
        } 
    } 
    if (isAcceptGzipEncoding()) {
        connection.setRequestProperty(HTTP_HEADER_ACCEPT_ENCODING, ENCODING_GZIP);
    } 
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerRequestExecutor

protected InputStream readResponseBody(HttpInvokerClientConfiguration config, HttpURLConnection con)

{
    if (isGzipResponse(con)) {
        return new GZIPInputStream(con.getInputStream());
    } else {
        return con.getInputStream();
    }
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerRequestExecutor

public void setConnectTimeout(int connectTimeout)

{
    this.connectTimeout = connectTimeout;
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerRequestExecutor

public void setReadTimeout(int readTimeout)

{
    this.readTimeout = readTimeout;
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerRequestExecutor

protected void validateResponse(HttpInvokerClientConfiguration config, HttpURLConnection con)

{
    if (con.getResponseCode() >= 300) {
        throw new IOException("Did not receive successful HTTP response: status code = " + con.getResponseCode() + ", status message = [" + con.getResponseMessage() + "]");
    } 
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerRequestExecutor

protected void writeRequestBody(HttpInvokerClientConfiguration config, HttpURLConnection con, ByteArrayOutputStream baos)

{
    baos.writeTo(con.getOutputStream());
}

SimpleHttpInvokerServiceExporter
extends RemoteInvocationSerializingExporter implements HttpHandler

org.springframework.remoting.httpinvoker.SimpleHttpInvokerServiceExporter

protected InputStream decorateInputStream(HttpExchange exchange, InputStream is)

{
    return is;
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerServiceExporter

protected OutputStream decorateOutputStream(HttpExchange exchange, OutputStream os)

{
    return os;
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerServiceExporter

protected RemoteInvocation readRemoteInvocation(HttpExchange exchange)

{
    return readRemoteInvocation(exchange, exchange.getRequestBody());
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerServiceExporter

protected RemoteInvocation readRemoteInvocation(HttpExchange exchange, InputStream is)

{
    ObjectInputStream ois = createObjectInputStream(decorateInputStream(exchange, is));
    return doReadRemoteInvocation(ois);
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerServiceExporter

protected void writeRemoteInvocationResult(HttpExchange exchange, RemoteInvocationResult result)

{
    exchange.getResponseHeaders().set("Content-Type", getContentType());
    exchange.sendResponseHeaders(200, 0);
    writeRemoteInvocationResult(exchange, result, exchange.getResponseBody());
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerServiceExporter

protected void writeRemoteInvocationResult(HttpExchange exchange, RemoteInvocationResult result, OutputStream os)

{
    ObjectOutputStream oos = createObjectOutputStream(decorateOutputStream(exchange, os));
    doWriteRemoteInvocationResult(result, oos);
    oos.flush();
}


AbstractJaxWsServiceExporter
implements BeanFactoryAware, InitializingBean, DisposableBean

org.springframework.remoting.jaxws.AbstractJaxWsServiceExporter

@Override public void afterPropertiesSet()

{
    publishEndpoints();
}
org.springframework.remoting.jaxws.AbstractJaxWsServiceExporter

protected Endpoint createEndpoint(Object bean)

{
    return (this.endpointFeatures != null ? Endpoint.create(this.bindingType, bean, this.endpointFeatures) : Endpoint.create(this.bindingType, bean));
}
org.springframework.remoting.jaxws.AbstractJaxWsServiceExporter

@Override public void destroy()

{
    for (Endpoint endpoint: this.publishedEndpoints) {
        endpoint.stop();
    }
}
org.springframework.remoting.jaxws.AbstractJaxWsServiceExporter

protected abstract void publishEndpoint(Endpoint endpoint, WebService annotation)

org.springframework.remoting.jaxws.AbstractJaxWsServiceExporter

protected abstract void publishEndpoint(Endpoint endpoint, WebServiceProvider annotation)

org.springframework.remoting.jaxws.AbstractJaxWsServiceExporter

@Override public void setBeanFactory(BeanFactory beanFactory)

{
    if (!(beanFactory instanceof ListableBeanFactory)) {
        throw new IllegalStateException(getClass().getSimpleName() + " requires a ListableBeanFactory");
    } 
    this.beanFactory = (ListableBeanFactory)beanFactory;
}
org.springframework.remoting.jaxws.AbstractJaxWsServiceExporter

public void setBindingType(String bindingType)

{
    this.bindingType = bindingType;
}
org.springframework.remoting.jaxws.AbstractJaxWsServiceExporter

public void setEndpointFeatures(WebServiceFeature... endpointFeatures)

{
    this.endpointFeatures = endpointFeatures;
}
org.springframework.remoting.jaxws.AbstractJaxWsServiceExporter

public void setEndpointProperties(Map<String, Object> endpointProperties)

{
    this.endpointProperties = endpointProperties;
}
org.springframework.remoting.jaxws.AbstractJaxWsServiceExporter

public void setExecutor(Executor executor)

{
    this.executor = executor;
}

JaxWsPortClientInterceptor
extends LocalJaxWsServiceFactory implements MethodInterceptor, BeanClassLoaderAware, InitializingBean

org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

public void addCustomProperty(String name, Object value)

{
    getCustomProperties().put(name, value);
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

@Override public void afterPropertiesSet()

{
    if (this.lookupServiceOnStartup) {
        prepare();
    } 
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

@Nullable protected Object doInvoke(MethodInvocation invocation)

{
    try {
        return doInvoke(invocation, getPortStub());
    } catch (SOAPFaultException ex) {
        throw new JaxWsSoapFaultException(ex);
    } catch (ProtocolException ex) {
        throw new RemoteConnectFailureException("Could not connect to remote service [" + getEndpointAddress() + "]", ex);
    } catch (WebServiceException ex) {
        throw new RemoteAccessException("Could not access remote service at [" + getEndpointAddress() + "]", ex);
    }
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

@Nullable protected Object doInvoke(MethodInvocation invocation, @Nullable Object portStub)

{
    Method method = invocation.getMethod();
    try {
        return method.invoke(portStub, invocation.getArguments());
    } catch (InvocationTargetException ex) {
        throw ex.getTargetException();
    } catch (Throwable ex) {
        throw new RemoteProxyFailureException("Invocation of stub method failed: " + method, ex);
    }
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

@Nullable protected ClassLoader getBeanClassLoader()

{
    return this.beanClassLoader;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

public Map<String, Object> getCustomProperties()

{
    if (this.customProperties == null) {
        this.customProperties = new HashMap<>();
    } 
    return this.customProperties;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

@Nullable public String getEndpointAddress()

{
    return this.endpointAddress;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

@Nullable public Service getJaxWsService()

{
    return this.jaxWsService;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

@Nullable public String getPassword()

{
    return this.password;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

@Nullable public String getPortName()

{
    return this.portName;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

@Nullable protected final QName getPortQName()

{
    return this.portQName;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

@Nullable protected Object getPortStub()

{
    return this.portStub;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

@Nullable public Class<?> getServiceInterface()

{
    return this.serviceInterface;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

@Nullable public String getSoapActionUri()

{
    return this.soapActionUri;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

@Nullable public String getUsername()

{
    return this.username;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

@Override @Nullable public Object invoke(MethodInvocation invocation)

{
    if (AopUtils.isToStringMethod(invocation.getMethod())) {
        return "JAX-WS proxy for port [" + getPortName() + "] of service [" + getServiceName() + "]";
    } 
    synchronized(this.preparationMonitor) {
        if (!isPrepared()) {
            prepare();
        } 
    }
    return doInvoke(invocation);
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

public boolean isMaintainSession()

{
    return this.maintainSession;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

protected boolean isPrepared()

{
    synchronized(this.preparationMonitor) {
        return (this.portStub != null);
    }
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

public boolean isUseSoapAction()

{
    return this.useSoapAction;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

public void prepare()

{
    Class<?> ifc = getServiceInterface();
    Assert.notNull(ifc, "Property 'serviceInterface' is required");
    WebService ann = ifc.getAnnotation(WebService.class);
    if (ann != null) {
        applyDefaultsFromAnnotation(ann);
    } 
    Service serviceToUse = getJaxWsService();
    if (serviceToUse == null) {
        serviceToUse = createJaxWsService();
    } 
    this.portQName = getQName(getPortName() != null ? getPortName() : ifc.getName());
    Object stub = getPortStub(serviceToUse, (getPortName() != null ? this.portQName : null));
    preparePortStub(stub);
    this.portStub = stub;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

@Override public void setBeanClassLoader(@Nullable ClassLoader classLoader)

{
    this.beanClassLoader = classLoader;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

public void setCustomProperties(Map<String, Object> customProperties)

{
    this.customProperties = customProperties;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

public void setEndpointAddress(@Nullable String endpointAddress)

{
    this.endpointAddress = endpointAddress;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

public void setJaxWsService(@Nullable Service jaxWsService)

{
    this.jaxWsService = jaxWsService;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

public void setLookupServiceOnStartup(boolean lookupServiceOnStartup)

{
    this.lookupServiceOnStartup = lookupServiceOnStartup;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

public void setMaintainSession(boolean maintainSession)

{
    this.maintainSession = maintainSession;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

public void setPassword(@Nullable String password)

{
    this.password = password;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

public void setPortFeatures(WebServiceFeature... features)

{
    this.portFeatures = features;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

public void setPortName(@Nullable String portName)

{
    this.portName = portName;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

public void setServiceInterface(@Nullable Class<?> serviceInterface)

{
    if (serviceInterface != null) {
        Assert.isTrue(serviceInterface.isInterface(), "'serviceInterface' must be an interface");
    } 
    this.serviceInterface = serviceInterface;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

public void setSoapActionUri(@Nullable String soapActionUri)

{
    this.soapActionUri = soapActionUri;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

public void setUseSoapAction(boolean useSoapAction)

{
    this.useSoapAction = useSoapAction;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor

public void setUsername(@Nullable String username)

{
    this.username = username;
}

JaxWsPortProxyFactoryBean
extends JaxWsPortClientInterceptor implements FactoryBean<Object>

org.springframework.remoting.jaxws.JaxWsPortProxyFactoryBean

@Override @Nullable public Object getObject()

{
    return this.serviceProxy;
}
org.springframework.remoting.jaxws.JaxWsPortProxyFactoryBean

@Override public Class<?> getObjectType()

{
    return getServiceInterface();
}
org.springframework.remoting.jaxws.JaxWsPortProxyFactoryBean

@Override public boolean isSingleton()

{
    return true;
}

JaxWsSoapFaultException
extends SoapFaultException

org.springframework.remoting.jaxws.JaxWsSoapFaultException

public JaxWsSoapFaultException JaxWsSoapFaultException(SOAPFaultException original)

{
    super(original.getMessage(), original);
}
org.springframework.remoting.jaxws.JaxWsSoapFaultException

public final SOAPFault getFault()

{
    return ((SOAPFaultException)getCause()).getFault();
}
org.springframework.remoting.jaxws.JaxWsSoapFaultException

@Override public String getFaultActor()

{
    return getFault().getFaultActor();
}
org.springframework.remoting.jaxws.JaxWsSoapFaultException

@Override public String getFaultCode()

{
    return getFault().getFaultCode();
}
org.springframework.remoting.jaxws.JaxWsSoapFaultException

@Override public QName getFaultCodeAsQName()

{
    return getFault().getFaultCodeAsQName();
}
org.springframework.remoting.jaxws.JaxWsSoapFaultException

@Override public String getFaultString()

{
    return getFault().getFaultString();
}

LocalJaxWsServiceFactory

org.springframework.remoting.jaxws.LocalJaxWsServiceFactory

@Nullable public String getNamespaceUri()

{
    return this.namespaceUri;
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactory

protected QName getQName(String name)

{
    return (getNamespaceUri() != null ? new QName(getNamespaceUri(), name) : new QName(name));
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactory

@Nullable public String getServiceName()

{
    return this.serviceName;
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactory

@Nullable public URL getWsdlDocumentUrl()

{
    return this.wsdlDocumentUrl;
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactory

public void setExecutor(Executor executor)

{
    this.executor = executor;
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactory

public void setHandlerResolver(HandlerResolver handlerResolver)

{
    this.handlerResolver = handlerResolver;
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactory

public void setNamespaceUri(@Nullable String namespaceUri)

{
    this.namespaceUri = (namespaceUri != null ? namespaceUri.trim() : null);
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactory

public void setServiceFeatures(WebServiceFeature... serviceFeatures)

{
    this.serviceFeatures = serviceFeatures;
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactory

public void setServiceName(@Nullable String serviceName)

{
    this.serviceName = serviceName;
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactory

public void setWsdlDocumentResource(Resource wsdlDocumentResource)

{
    Assert.notNull(wsdlDocumentResource, "WSDL Resource must not be null");
    this.wsdlDocumentUrl = wsdlDocumentResource.getURL();
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactory

public void setWsdlDocumentUrl(@Nullable URL wsdlDocumentUrl)

{
    this.wsdlDocumentUrl = wsdlDocumentUrl;
}

LocalJaxWsServiceFactoryBean
extends LocalJaxWsServiceFactory implements FactoryBean<Service>, InitializingBean

org.springframework.remoting.jaxws.LocalJaxWsServiceFactoryBean

@Override public void afterPropertiesSet()

{
    this.service = createJaxWsService();
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactoryBean

@Override @Nullable public Service getObject()

{
    return this.service;
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactoryBean

@Override public Class<?> getObjectType()

{
    return (this.service != null ? this.service.getClass() : Service.class);
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactoryBean

@Override public boolean isSingleton()

{
    return true;
}

SimpleHttpServerJaxWsServiceExporter
extends AbstractJaxWsServiceExporter

org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter

protected String calculateEndpointPath(Endpoint endpoint, String serviceName)

{
    return this.basePath + serviceName;
}
org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter

@Override public void destroy()

{
    super.destroy();
    if (this.server != null && this.localServer) {
        logger.info("Stopping HttpServer");
        this.server.stop(this.shutdownDelay);
    } 
}
org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter

protected final Log logger

org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter

@Override protected void publishEndpoint(Endpoint endpoint, WebService annotation)

{
    endpoint.publish(buildHttpContext(endpoint, annotation.serviceName()));
}
org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter

@Override protected void publishEndpoint(Endpoint endpoint, WebServiceProvider annotation)

{
    endpoint.publish(buildHttpContext(endpoint, annotation.serviceName()));
}
org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter

public void setAuthenticator(Authenticator authenticator)

{
    this.authenticator = authenticator;
}
org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter

public void setBacklog(int backlog)

{
    this.backlog = backlog;
}
org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter

public void setBasePath(String basePath)

{
    this.basePath = basePath;
}
org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter

public void setFilters(List<Filter> filters)

{
    this.filters = filters;
}
org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter

public void setHostname(String hostname)

{
    this.hostname = hostname;
}
org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter

public void setPort(int port)

{
    this.port = port;
}
org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter

public void setServer(HttpServer server)

{
    this.server = server;
}
org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter

public void setShutdownDelay(int shutdownDelay)

{
    this.shutdownDelay = shutdownDelay;
}

SimpleJaxWsServiceExporter
extends AbstractJaxWsServiceExporter

org.springframework.remoting.jaxws.SimpleJaxWsServiceExporter

public static final String DEFAULT_BASE_ADDRESS

org.springframework.remoting.jaxws.SimpleJaxWsServiceExporter

protected String calculateEndpointAddress(Endpoint endpoint, String serviceName)

{
    String fullAddress = this.baseAddress + serviceName;
    if (endpoint.getClass().getName().startsWith("weblogic.")) {
        fullAddress = fullAddress + "/";
    } 
    return fullAddress;
}
org.springframework.remoting.jaxws.SimpleJaxWsServiceExporter

@Override protected void publishEndpoint(Endpoint endpoint, WebService annotation)

{
    endpoint.publish(calculateEndpointAddress(endpoint, annotation.serviceName()));
}
org.springframework.remoting.jaxws.SimpleJaxWsServiceExporter

@Override protected void publishEndpoint(Endpoint endpoint, WebServiceProvider annotation)

{
    endpoint.publish(calculateEndpointAddress(endpoint, annotation.serviceName()));
}
org.springframework.remoting.jaxws.SimpleJaxWsServiceExporter

public void setBaseAddress(String baseAddress)

{
    this.baseAddress = baseAddress;
}


HttpMediaTypeException
extends ServletException

org.springframework.web.HttpMediaTypeException

protected HttpMediaTypeException HttpMediaTypeException(String message)

{
    super(message);
    this.supportedMediaTypes = Collections.emptyList();
}
org.springframework.web.HttpMediaTypeException

protected HttpMediaTypeException HttpMediaTypeException(String message, List<MediaType> supportedMediaTypes)

{
    super(message);
    this.supportedMediaTypes = Collections.unmodifiableList(supportedMediaTypes);
}
org.springframework.web.HttpMediaTypeException

public List<MediaType> getSupportedMediaTypes()

{
    return this.supportedMediaTypes;
}

HttpMediaTypeNotAcceptableException
extends HttpMediaTypeException

org.springframework.web.HttpMediaTypeNotAcceptableException

public HttpMediaTypeNotAcceptableException HttpMediaTypeNotAcceptableException(String message)

{
    super(message);
}
org.springframework.web.HttpMediaTypeNotAcceptableException

public HttpMediaTypeNotAcceptableException HttpMediaTypeNotAcceptableException(List<MediaType> supportedMediaTypes)

{
    super("Could not find acceptable representation", supportedMediaTypes);
}

HttpMediaTypeNotSupportedException
extends HttpMediaTypeException

org.springframework.web.HttpMediaTypeNotSupportedException

public HttpMediaTypeNotSupportedException HttpMediaTypeNotSupportedException(String message)

{
    super(message);
    this.contentType = null;
}
org.springframework.web.HttpMediaTypeNotSupportedException

public HttpMediaTypeNotSupportedException HttpMediaTypeNotSupportedException(@Nullable MediaType contentType, List<MediaType> supportedMediaTypes)

{
    this(contentType, supportedMediaTypes, "Content type '" + (contentType != null ? contentType : "") + "' not supported");
}
org.springframework.web.HttpMediaTypeNotSupportedException

public HttpMediaTypeNotSupportedException HttpMediaTypeNotSupportedException(@Nullable MediaType contentType, List<MediaType> supportedMediaTypes, String msg)

{
    super(msg, supportedMediaTypes);
    this.contentType = contentType;
}
org.springframework.web.HttpMediaTypeNotSupportedException

@Nullable public MediaType getContentType()

{
    return this.contentType;
}

HttpRequestHandler

HttpRequestMethodNotSupportedException
extends ServletException

org.springframework.web.HttpRequestMethodNotSupportedException

public HttpRequestMethodNotSupportedException HttpRequestMethodNotSupportedException(String method)

{
    this(method, (String[])null);
}
org.springframework.web.HttpRequestMethodNotSupportedException

public HttpRequestMethodNotSupportedException HttpRequestMethodNotSupportedException(String method, String msg)

{
    this(method, null, msg);
}
org.springframework.web.HttpRequestMethodNotSupportedException

public HttpRequestMethodNotSupportedException HttpRequestMethodNotSupportedException(String method, @Nullable Collection<String> supportedMethods)

{
    this(method, (supportedMethods != null ? StringUtils.toStringArray(supportedMethods) : null));
}
org.springframework.web.HttpRequestMethodNotSupportedException

public HttpRequestMethodNotSupportedException HttpRequestMethodNotSupportedException(String method, @Nullable String[] supportedMethods)

{
    this(method, supportedMethods, "Request method '" + method + "' not supported");
}
org.springframework.web.HttpRequestMethodNotSupportedException

public HttpRequestMethodNotSupportedException HttpRequestMethodNotSupportedException(String method, @Nullable String[] supportedMethods, String msg)

{
    super(msg);
    this.method = method;
    this.supportedMethods = supportedMethods;
}
org.springframework.web.HttpRequestMethodNotSupportedException

public String getMethod()

{
    return this.method;
}
org.springframework.web.HttpRequestMethodNotSupportedException

@Nullable public Set<HttpMethod> getSupportedHttpMethods()

{
    if (this.supportedMethods == null) {
        return null;
    } 
    List<HttpMethod> supportedMethods = new LinkedList<>();
    for (String value: this.supportedMethods) {
        HttpMethod resolved = HttpMethod.resolve(value);
        if (resolved != null) {
            supportedMethods.add(resolved);
        } 
    }
    return EnumSet.copyOf(supportedMethods);
}
org.springframework.web.HttpRequestMethodNotSupportedException

@Nullable public String[] getSupportedMethods()

{
    return this.supportedMethods;
}

HttpSessionRequiredException
extends ServletException

org.springframework.web.HttpSessionRequiredException

public HttpSessionRequiredException HttpSessionRequiredException(String msg)

{
    super(msg);
    this.expectedAttribute = null;
}
org.springframework.web.HttpSessionRequiredException

public HttpSessionRequiredException HttpSessionRequiredException(String msg, String expectedAttribute)

{
    super(msg);
    this.expectedAttribute = expectedAttribute;
}
org.springframework.web.HttpSessionRequiredException

@Nullable public String getExpectedAttribute()

{
    return this.expectedAttribute;
}

SpringServletContainerInitializer
implements ServletContainerInitializer

org.springframework.web.SpringServletContainerInitializer

@Override public void onStartup(@Nullable Set<Class<?>> webAppInitializerClasses, ServletContext servletContext)

{
    List<WebApplicationInitializer> initializers = new LinkedList<>();
    if (webAppInitializerClasses != null) {
        for (Class<?> waiClass: webAppInitializerClasses) {
            if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) && WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
                try {
                    initializers.add((WebApplicationInitializer)ReflectionUtils.accessibleConstructor(waiClass).newInstance());
                } catch (Throwable ex) {
                    throw new ServletException("Failed to instantiate WebApplicationInitializer class", ex);
                }
            } 
        }
    } 
    if (initializers.isEmpty()) {
        servletContext.log("No Spring WebApplicationInitializer types detected on classpath");
        return ;
    } 
    servletContext.log(initializers.size() + " Spring WebApplicationInitializers detected on classpath");
    AnnotationAwareOrderComparator.sort(initializers);
    for (WebApplicationInitializer initializer: initializers) {
        initializer.onStartup(servletContext);
    }
}

WebApplicationInitializer

AbstractMappingContentNegotiationStrategy
extends MappingMediaTypeFileExtensionResolver implements ContentNegotiationStrategy

org.springframework.web.accept.AbstractMappingContentNegotiationStrategy

public AbstractMappingContentNegotiationStrategy AbstractMappingContentNegotiationStrategy(@Nullable Map<String, MediaType> mediaTypes)

{
    super(mediaTypes);
}
org.springframework.web.accept.AbstractMappingContentNegotiationStrategy

@Nullable protected abstract String getMediaTypeKey(NativeWebRequest request)

org.springframework.web.accept.AbstractMappingContentNegotiationStrategy

protected void handleMatch(String key, MediaType mediaType)

{
}
org.springframework.web.accept.AbstractMappingContentNegotiationStrategy

@Nullable protected MediaType handleNoMatch(NativeWebRequest request, String key)

{
    if (!isUseRegisteredExtensionsOnly()) {
        Optional<MediaType> mediaType = MediaTypeFactory.getMediaType("file." + key);
        if (mediaType.isPresent()) {
            return mediaType.get();
        } 
    } 
    if (isIgnoreUnknownExtensions()) {
        return null;
    } 
    throw new HttpMediaTypeNotAcceptableException(getAllMediaTypes());
}
org.springframework.web.accept.AbstractMappingContentNegotiationStrategy

public boolean isIgnoreUnknownExtensions()

{
    return this.ignoreUnknownExtensions;
}
org.springframework.web.accept.AbstractMappingContentNegotiationStrategy

public boolean isUseRegisteredExtensionsOnly()

{
    return this.useRegisteredExtensionsOnly;
}
org.springframework.web.accept.AbstractMappingContentNegotiationStrategy

protected final Log logger

org.springframework.web.accept.AbstractMappingContentNegotiationStrategy

public List<MediaType> resolveMediaTypeKey(NativeWebRequest webRequest, @Nullable String key)

{
    if (StringUtils.hasText(key)) {
        MediaType mediaType = lookupMediaType(key);
        if (mediaType != null) {
            handleMatch(key, mediaType);
            return Collections.singletonList(mediaType);
        } 
        mediaType = handleNoMatch(webRequest, key);
        if (mediaType != null) {
            addMapping(key, mediaType);
            return Collections.singletonList(mediaType);
        } 
    } 
    return MEDIA_TYPE_ALL_LIST;
}
org.springframework.web.accept.AbstractMappingContentNegotiationStrategy

@Override public List<MediaType> resolveMediaTypes(NativeWebRequest webRequest)

{
    return resolveMediaTypeKey(webRequest, getMediaTypeKey(webRequest));
}
org.springframework.web.accept.AbstractMappingContentNegotiationStrategy

public void setIgnoreUnknownExtensions(boolean ignoreUnknownExtensions)

{
    this.ignoreUnknownExtensions = ignoreUnknownExtensions;
}
org.springframework.web.accept.AbstractMappingContentNegotiationStrategy

public void setUseRegisteredExtensionsOnly(boolean useRegisteredExtensionsOnly)

{
    this.useRegisteredExtensionsOnly = useRegisteredExtensionsOnly;
}

ContentNegotiationManager
implements ContentNegotiationStrategy, MediaTypeFileExtensionResolver

org.springframework.web.accept.ContentNegotiationManager

public ContentNegotiationManager ContentNegotiationManager(ContentNegotiationStrategy... strategies)

{
    this(Arrays.asList(strategies));
}
org.springframework.web.accept.ContentNegotiationManager

public ContentNegotiationManager ContentNegotiationManager()

{
    this(new HeaderContentNegotiationStrategy());
}
org.springframework.web.accept.ContentNegotiationManager

public void addFileExtensionResolvers(MediaTypeFileExtensionResolver... resolvers)

{
    Collections.addAll(this.resolvers, resolvers);
}
org.springframework.web.accept.ContentNegotiationManager

@Override public List<String> getAllFileExtensions()

{
    Set<String> result = new LinkedHashSet<>();
    for (MediaTypeFileExtensionResolver resolver: this.resolvers) {
        result.addAll(resolver.getAllFileExtensions());
    }
    return new ArrayList<>(result);
}
org.springframework.web.accept.ContentNegotiationManager

public List<ContentNegotiationStrategy> getStrategies()

{
    return this.strategies;
}
org.springframework.web.accept.ContentNegotiationManager

<T>@SuppressWarnings("unchecked") @Nullable public T getStrategy(Class<T> strategyType)

{
    for (ContentNegotiationStrategy strategy: getStrategies()) {
        if (strategyType.isInstance(strategy)) {
            return (T)strategy;
        } 
    }
    return null;
}
org.springframework.web.accept.ContentNegotiationManager

@Override public List<String> resolveFileExtensions(MediaType mediaType)

{
    Set<String> result = new LinkedHashSet<>();
    for (MediaTypeFileExtensionResolver resolver: this.resolvers) {
        result.addAll(resolver.resolveFileExtensions(mediaType));
    }
    return new ArrayList<>(result);
}
org.springframework.web.accept.ContentNegotiationManager

@Override public List<MediaType> resolveMediaTypes(NativeWebRequest request)

{
    for (ContentNegotiationStrategy strategy: this.strategies) {
        List<MediaType> mediaTypes = strategy.resolveMediaTypes(request);
        if (mediaTypes.equals(MEDIA_TYPE_ALL_LIST)) {
            continue;
        } 
        return mediaTypes;
    }
    return MEDIA_TYPE_ALL_LIST;
}

ContentNegotiationManagerFactoryBean
implements FactoryBean<ContentNegotiationManager>, ServletContextAware, InitializingBean

org.springframework.web.accept.ContentNegotiationManagerFactoryBean

public void addMediaType(String fileExtension, MediaType mediaType)

{
    this.mediaTypes.put(fileExtension, mediaType);
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean

public void addMediaTypes(@Nullable Map<String, MediaType> mediaTypes)

{
    if (mediaTypes != null) {
        this.mediaTypes.putAll(mediaTypes);
    } 
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean

@Override public void afterPropertiesSet()

{
    build();
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean

public ContentNegotiationManager build()

{
    List<ContentNegotiationStrategy> strategies = new ArrayList<>();
    if (this.strategies != null) {
        strategies.addAll(this.strategies);
    } else {
        if (this.favorPathExtension) {
            PathExtensionContentNegotiationStrategy strategy;
            if (this.servletContext != null && !useRegisteredExtensionsOnly()) {
                strategy = new ServletPathExtensionContentNegotiationStrategy(this.servletContext, this.mediaTypes);
            } else {
                strategy = new PathExtensionContentNegotiationStrategy(this.mediaTypes);
            }
            strategy.setIgnoreUnknownExtensions(this.ignoreUnknownPathExtensions);
            if (this.useRegisteredExtensionsOnly != null) {
                strategy.setUseRegisteredExtensionsOnly(this.useRegisteredExtensionsOnly);
            } 
            strategies.add(strategy);
        } 
        if (this.favorParameter) {
            ParameterContentNegotiationStrategy strategy = new ParameterContentNegotiationStrategy(this.mediaTypes);
            strategy.setParameterName(this.parameterName);
            if (this.useRegisteredExtensionsOnly != null) {
                strategy.setUseRegisteredExtensionsOnly(this.useRegisteredExtensionsOnly);
            } else {
                strategy.setUseRegisteredExtensionsOnly(true);
            }
            strategies.add(strategy);
        } 
        if (!this.ignoreAcceptHeader) {
            strategies.add(new HeaderContentNegotiationStrategy());
        } 
        if (this.defaultNegotiationStrategy != null) {
            strategies.add(this.defaultNegotiationStrategy);
        } 
    }
    this.contentNegotiationManager = new ContentNegotiationManager(strategies);
    return this.contentNegotiationManager;
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean

@Override @Nullable public ContentNegotiationManager getObject()

{
    return this.contentNegotiationManager;
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean

@Override public Class<?> getObjectType()

{
    return ContentNegotiationManager.class;
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean

@Override public boolean isSingleton()

{
    return true;
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean

public void setDefaultContentType(MediaType contentType)

{
    this.defaultNegotiationStrategy = new FixedContentNegotiationStrategy(contentType);
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean

public void setDefaultContentTypeStrategy(ContentNegotiationStrategy strategy)

{
    this.defaultNegotiationStrategy = strategy;
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean

public void setDefaultContentTypes(List<MediaType> contentTypes)

{
    this.defaultNegotiationStrategy = new FixedContentNegotiationStrategy(contentTypes);
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean

public void setFavorParameter(boolean favorParameter)

{
    this.favorParameter = favorParameter;
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean

public void setFavorPathExtension(boolean favorPathExtension)

{
    this.favorPathExtension = favorPathExtension;
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean

public void setIgnoreAcceptHeader(boolean ignoreAcceptHeader)

{
    this.ignoreAcceptHeader = ignoreAcceptHeader;
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean

public void setIgnoreUnknownPathExtensions(boolean ignore)

{
    this.ignoreUnknownPathExtensions = ignore;
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean

public void setParameterName(String parameterName)

{
    Assert.notNull(parameterName, "parameterName is required");
    this.parameterName = parameterName;
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean

@Override public void setServletContext(ServletContext servletContext)

{
    this.servletContext = servletContext;
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean

public void setStrategies(@Nullable List<ContentNegotiationStrategy> strategies)

{
    this.strategies = (strategies != null ? new ArrayList<>(strategies) : null);
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean

@Deprecated public void setUseJaf(boolean useJaf)

{
    setUseRegisteredExtensionsOnly(!useJaf);
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean

public void setUseRegisteredExtensionsOnly(boolean useRegisteredExtensionsOnly)

{
    this.useRegisteredExtensionsOnly = useRegisteredExtensionsOnly;
}

ContentNegotiationStrategy

FixedContentNegotiationStrategy
implements ContentNegotiationStrategy

org.springframework.web.accept.FixedContentNegotiationStrategy

public FixedContentNegotiationStrategy FixedContentNegotiationStrategy(MediaType contentType)

{
    this(Collections.singletonList(contentType));
}
org.springframework.web.accept.FixedContentNegotiationStrategy

public FixedContentNegotiationStrategy FixedContentNegotiationStrategy(List<MediaType> contentTypes)

{
    Assert.notNull(contentTypes, "'contentTypes' must not be null");
    this.contentTypes = Collections.unmodifiableList(contentTypes);
}
org.springframework.web.accept.FixedContentNegotiationStrategy

public List<MediaType> getContentTypes()

{
    return this.contentTypes;
}
org.springframework.web.accept.FixedContentNegotiationStrategy

@Override public List<MediaType> resolveMediaTypes(NativeWebRequest request)

{
    return this.contentTypes;
}

HeaderContentNegotiationStrategy
implements ContentNegotiationStrategy


MappingMediaTypeFileExtensionResolver
implements MediaTypeFileExtensionResolver

org.springframework.web.accept.MappingMediaTypeFileExtensionResolver

public MappingMediaTypeFileExtensionResolver MappingMediaTypeFileExtensionResolver(@Nullable Map<String, MediaType> mediaTypes)

{
    if (mediaTypes != null) {
        List<String> allFileExtensions = new ArrayList<>();
        mediaTypes.forEach((extension, mediaType) -> {
            String lowerCaseExtension = extension.toLowerCase(Locale.ENGLISH);
            this.mediaTypes.put(lowerCaseExtension, mediaType);
            addFileExtension(mediaType, lowerCaseExtension);
            allFileExtensions.add(lowerCaseExtension);
        });
        this.allFileExtensions.addAll(allFileExtensions);
    } 
}
org.springframework.web.accept.MappingMediaTypeFileExtensionResolver

protected void addMapping(String extension, MediaType mediaType)

{
    MediaType previous = this.mediaTypes.putIfAbsent(extension, mediaType);
    if (previous == null) {
        addFileExtension(mediaType, extension);
        this.allFileExtensions.add(extension);
    } 
}
org.springframework.web.accept.MappingMediaTypeFileExtensionResolver

@Override public List<String> getAllFileExtensions()

{
    return Collections.unmodifiableList(this.allFileExtensions);
}
org.springframework.web.accept.MappingMediaTypeFileExtensionResolver

protected List<MediaType> getAllMediaTypes()

{
    return new ArrayList<>(this.mediaTypes.values());
}
org.springframework.web.accept.MappingMediaTypeFileExtensionResolver

public Map<String, MediaType> getMediaTypes()

{
    return this.mediaTypes;
}
org.springframework.web.accept.MappingMediaTypeFileExtensionResolver

@Nullable protected MediaType lookupMediaType(String extension)

{
    return this.mediaTypes.get(extension.toLowerCase(Locale.ENGLISH));
}
org.springframework.web.accept.MappingMediaTypeFileExtensionResolver

@Override public List<String> resolveFileExtensions(MediaType mediaType)

{
    List<String> fileExtensions = this.fileExtensions.get(mediaType);
    return (fileExtensions != null ? fileExtensions : Collections.emptyList());
}

MediaTypeFileExtensionResolver

ParameterContentNegotiationStrategy
extends AbstractMappingContentNegotiationStrategy

org.springframework.web.accept.ParameterContentNegotiationStrategy

public ParameterContentNegotiationStrategy ParameterContentNegotiationStrategy(Map<String, MediaType> mediaTypes)

{
    super(mediaTypes);
}
org.springframework.web.accept.ParameterContentNegotiationStrategy

@Override @Nullable protected String getMediaTypeKey(NativeWebRequest request)

{
    return request.getParameter(getParameterName());
}
org.springframework.web.accept.ParameterContentNegotiationStrategy

public String getParameterName()

{
    return this.parameterName;
}
org.springframework.web.accept.ParameterContentNegotiationStrategy

public void setParameterName(String parameterName)

{
    Assert.notNull(parameterName, "'parameterName' is required");
    this.parameterName = parameterName;
}

PathExtensionContentNegotiationStrategy
extends AbstractMappingContentNegotiationStrategy

org.springframework.web.accept.PathExtensionContentNegotiationStrategy

public PathExtensionContentNegotiationStrategy PathExtensionContentNegotiationStrategy()

{
    this(null);
}
org.springframework.web.accept.PathExtensionContentNegotiationStrategy

public PathExtensionContentNegotiationStrategy PathExtensionContentNegotiationStrategy(@Nullable Map<String, MediaType> mediaTypes)

{
    super(mediaTypes);
    setUseRegisteredExtensionsOnly(false);
    setIgnoreUnknownExtensions(true);
    this.urlPathHelper.setUrlDecode(false);
}
org.springframework.web.accept.PathExtensionContentNegotiationStrategy

@Override @Nullable protected String getMediaTypeKey(NativeWebRequest webRequest)

{
    HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
    if (request == null) {
        return null;
    } 
    String path = this.urlPathHelper.getLookupPathForRequest(request);
    String extension = UriUtils.extractFileExtension(path);
    return (StringUtils.hasText(extension) ? extension.toLowerCase(Locale.ENGLISH) : null);
}
org.springframework.web.accept.PathExtensionContentNegotiationStrategy

public void setUrlPathHelper(UrlPathHelper urlPathHelper)

{
    this.urlPathHelper = urlPathHelper;
}
org.springframework.web.accept.PathExtensionContentNegotiationStrategy

@Deprecated public void setUseJaf(boolean useJaf)

{
    setUseRegisteredExtensionsOnly(!useJaf);
}

ServletPathExtensionContentNegotiationStrategy
extends PathExtensionContentNegotiationStrategy

org.springframework.web.accept.ServletPathExtensionContentNegotiationStrategy

public ServletPathExtensionContentNegotiationStrategy ServletPathExtensionContentNegotiationStrategy(ServletContext context)

{
    this(context, null);
}
org.springframework.web.accept.ServletPathExtensionContentNegotiationStrategy

public ServletPathExtensionContentNegotiationStrategy ServletPathExtensionContentNegotiationStrategy(ServletContext servletContext, @Nullable Map<String, MediaType> mediaTypes)

{
    super(mediaTypes);
    Assert.notNull(servletContext, "ServletContext is required");
    this.servletContext = servletContext;
}
org.springframework.web.accept.ServletPathExtensionContentNegotiationStrategy

@Override public MediaType getMediaTypeForResource(Resource resource)

{
    MediaType mediaType = null;
    String mimeType = this.servletContext.getMimeType(resource.getFilename());
    if (StringUtils.hasText(mimeType)) {
        mediaType = MediaType.parseMediaType(mimeType);
    } 
    if (mediaType == null || MediaType.APPLICATION_OCTET_STREAM.equals(mediaType)) {
        MediaType superMediaType = super.getMediaTypeForResource(resource);
        if (superMediaType != null) {
            mediaType = superMediaType;
        } 
    } 
    return mediaType;
}
org.springframework.web.accept.ServletPathExtensionContentNegotiationStrategy

@Override @Nullable protected MediaType handleNoMatch(NativeWebRequest webRequest, String extension)

{
    MediaType mediaType = null;
    String mimeType = this.servletContext.getMimeType("file." + extension);
    if (StringUtils.hasText(mimeType)) {
        mediaType = MediaType.parseMediaType(mimeType);
    } 
    if (mediaType == null || MediaType.APPLICATION_OCTET_STREAM.equals(mediaType)) {
        MediaType superMediaType = super.handleNoMatch(webRequest, extension);
        if (superMediaType != null) {
            mediaType = superMediaType;
        } 
    } 
    return mediaType;
}


EscapedErrors
implements Errors

org.springframework.web.bind.EscapedErrors

public EscapedErrors EscapedErrors(Errors source)

{
    Assert.notNull(source, "Errors source must not be null");
    this.source = source;
}
org.springframework.web.bind.EscapedErrors

@Override public void addAllErrors(Errors errors)

{
    this.source.addAllErrors(errors);
}
org.springframework.web.bind.EscapedErrors

@Override public List<ObjectError> getAllErrors()

{
    return escapeObjectErrors(this.source.getAllErrors());
}
org.springframework.web.bind.EscapedErrors

@Override public int getErrorCount()

{
    return this.source.getErrorCount();
}
org.springframework.web.bind.EscapedErrors

@Override @Nullable public FieldError getFieldError()

{
    return this.source.getFieldError();
}
org.springframework.web.bind.EscapedErrors

@Override @Nullable public FieldError getFieldError(String field)

{
    return escapeObjectError(this.source.getFieldError(field));
}
org.springframework.web.bind.EscapedErrors

@Override public int getFieldErrorCount()

{
    return this.source.getFieldErrorCount();
}
org.springframework.web.bind.EscapedErrors

@Override public int getFieldErrorCount(String field)

{
    return this.source.getFieldErrorCount(field);
}
org.springframework.web.bind.EscapedErrors

@Override public List<FieldError> getFieldErrors()

{
    return this.source.getFieldErrors();
}
org.springframework.web.bind.EscapedErrors

@Override public List<FieldError> getFieldErrors(String field)

{
    return escapeObjectErrors(this.source.getFieldErrors(field));
}
org.springframework.web.bind.EscapedErrors

@Override @Nullable public Class<?> getFieldType(String field)

{
    return this.source.getFieldType(field);
}
org.springframework.web.bind.EscapedErrors

@Override @Nullable public Object getFieldValue(String field)

{
    Object value = this.source.getFieldValue(field);
    return (value instanceof String ? HtmlUtils.htmlEscape((String)value) : value);
}
org.springframework.web.bind.EscapedErrors

@Override @Nullable public ObjectError getGlobalError()

{
    return escapeObjectError(this.source.getGlobalError());
}
org.springframework.web.bind.EscapedErrors

@Override public int getGlobalErrorCount()

{
    return this.source.getGlobalErrorCount();
}
org.springframework.web.bind.EscapedErrors

@Override public List<ObjectError> getGlobalErrors()

{
    return escapeObjectErrors(this.source.getGlobalErrors());
}
org.springframework.web.bind.EscapedErrors

@Override public String getNestedPath()

{
    return this.source.getNestedPath();
}
org.springframework.web.bind.EscapedErrors

@Override public String getObjectName()

{
    return this.source.getObjectName();
}
org.springframework.web.bind.EscapedErrors

public Errors getSource()

{
    return this.source;
}
org.springframework.web.bind.EscapedErrors

@Override public boolean hasErrors()

{
    return this.source.hasErrors();
}
org.springframework.web.bind.EscapedErrors

@Override public boolean hasFieldErrors()

{
    return this.source.hasFieldErrors();
}
org.springframework.web.bind.EscapedErrors

@Override public boolean hasFieldErrors(String field)

{
    return this.source.hasFieldErrors(field);
}
org.springframework.web.bind.EscapedErrors

@Override public boolean hasGlobalErrors()

{
    return this.source.hasGlobalErrors();
}
org.springframework.web.bind.EscapedErrors

@Override public void popNestedPath()

{
    this.source.popNestedPath();
}
org.springframework.web.bind.EscapedErrors

@Override public void pushNestedPath(String subPath)

{
    this.source.pushNestedPath(subPath);
}
org.springframework.web.bind.EscapedErrors

@Override public void reject(String errorCode)

{
    this.source.reject(errorCode);
}
org.springframework.web.bind.EscapedErrors

@Override public void reject(String errorCode, String defaultMessage)

{
    this.source.reject(errorCode, defaultMessage);
}
org.springframework.web.bind.EscapedErrors

@Override public void reject(String errorCode, @Nullable Object[] errorArgs, @Nullable String defaultMessage)

{
    this.source.reject(errorCode, errorArgs, defaultMessage);
}
org.springframework.web.bind.EscapedErrors

@Override public void rejectValue(@Nullable String field, String errorCode)

{
    this.source.rejectValue(field, errorCode);
}
org.springframework.web.bind.EscapedErrors

@Override public void rejectValue(@Nullable String field, String errorCode, String defaultMessage)

{
    this.source.rejectValue(field, errorCode, defaultMessage);
}
org.springframework.web.bind.EscapedErrors

@Override public void rejectValue(@Nullable String field, String errorCode, @Nullable Object[] errorArgs, @Nullable String defaultMessage)

{
    this.source.rejectValue(field, errorCode, errorArgs, defaultMessage);
}
org.springframework.web.bind.EscapedErrors

@Override public void setNestedPath(String nestedPath)

{
    this.source.setNestedPath(nestedPath);
}

MethodArgumentNotValidException
extends Exception

org.springframework.web.bind.MethodArgumentNotValidException

public MethodArgumentNotValidException MethodArgumentNotValidException(MethodParameter parameter, BindingResult bindingResult)

{
    this.parameter = parameter;
    this.bindingResult = bindingResult;
}
org.springframework.web.bind.MethodArgumentNotValidException

public BindingResult getBindingResult()

{
    return this.bindingResult;
}
org.springframework.web.bind.MethodArgumentNotValidException

public MethodParameter getParameter()

{
    return this.parameter;
}

MissingMatrixVariableException
extends ServletRequestBindingException

org.springframework.web.bind.MissingMatrixVariableException

public MissingMatrixVariableException MissingMatrixVariableException(String variableName, MethodParameter parameter)

{
    super("");
    this.variableName = variableName;
    this.parameter = parameter;
}
org.springframework.web.bind.MissingMatrixVariableException

public final MethodParameter getParameter()

{
    return this.parameter;
}
org.springframework.web.bind.MissingMatrixVariableException

public final String getVariableName()

{
    return this.variableName;
}

MissingPathVariableException
extends ServletRequestBindingException

org.springframework.web.bind.MissingPathVariableException

public MissingPathVariableException MissingPathVariableException(String variableName, MethodParameter parameter)

{
    super("");
    this.variableName = variableName;
    this.parameter = parameter;
}
org.springframework.web.bind.MissingPathVariableException

public final MethodParameter getParameter()

{
    return this.parameter;
}
org.springframework.web.bind.MissingPathVariableException

public final String getVariableName()

{
    return this.variableName;
}

MissingRequestCookieException
extends ServletRequestBindingException

org.springframework.web.bind.MissingRequestCookieException

public MissingRequestCookieException MissingRequestCookieException(String cookieName, MethodParameter parameter)

{
    super("");
    this.cookieName = cookieName;
    this.parameter = parameter;
}
org.springframework.web.bind.MissingRequestCookieException

public final String getCookieName()

{
    return this.cookieName;
}
org.springframework.web.bind.MissingRequestCookieException

public final MethodParameter getParameter()

{
    return this.parameter;
}

MissingRequestHeaderException
extends ServletRequestBindingException

org.springframework.web.bind.MissingRequestHeaderException

public MissingRequestHeaderException MissingRequestHeaderException(String headerName, MethodParameter parameter)

{
    super("");
    this.headerName = headerName;
    this.parameter = parameter;
}
org.springframework.web.bind.MissingRequestHeaderException

public final String getHeaderName()

{
    return this.headerName;
}
org.springframework.web.bind.MissingRequestHeaderException

public final MethodParameter getParameter()

{
    return this.parameter;
}

MissingServletRequestParameterException
extends ServletRequestBindingException

org.springframework.web.bind.MissingServletRequestParameterException

public MissingServletRequestParameterException MissingServletRequestParameterException(String parameterName, String parameterType)

{
    super("");
    this.parameterName = parameterName;
    this.parameterType = parameterType;
}
org.springframework.web.bind.MissingServletRequestParameterException

@Override public String getMessage()

{
    return "Required " + this.parameterType + " parameter '" + this.parameterName + "' is not present";
}
org.springframework.web.bind.MissingServletRequestParameterException

public final String getParameterName()

{
    return this.parameterName;
}
org.springframework.web.bind.MissingServletRequestParameterException

public final String getParameterType()

{
    return this.parameterType;
}

ServletRequestBindingException
extends NestedServletException

org.springframework.web.bind.ServletRequestBindingException

public ServletRequestBindingException ServletRequestBindingException(String msg)

{
    super(msg);
}
org.springframework.web.bind.ServletRequestBindingException

public ServletRequestBindingException ServletRequestBindingException(String msg, Throwable cause)

{
    super(msg, cause);
}

ServletRequestDataBinder
extends WebDataBinder

org.springframework.web.bind.ServletRequestDataBinder

public ServletRequestDataBinder ServletRequestDataBinder(@Nullable Object target)

{
    super(target);
}
org.springframework.web.bind.ServletRequestDataBinder

public ServletRequestDataBinder ServletRequestDataBinder(@Nullable Object target, String objectName)

{
    super(target, objectName);
}
org.springframework.web.bind.ServletRequestDataBinder

protected void addBindValues(MutablePropertyValues mpvs, ServletRequest request)

{
}

ServletRequestParameterPropertyValues
extends MutablePropertyValues

org.springframework.web.bind.ServletRequestParameterPropertyValues

public static final String DEFAULT_PREFIX_SEPARATOR

org.springframework.web.bind.ServletRequestParameterPropertyValues

public ServletRequestParameterPropertyValues ServletRequestParameterPropertyValues(ServletRequest request)

{
    this(request, null, null);
}
org.springframework.web.bind.ServletRequestParameterPropertyValues

public ServletRequestParameterPropertyValues ServletRequestParameterPropertyValues(ServletRequest request, @Nullable String prefix)

{
    this(request, prefix, DEFAULT_PREFIX_SEPARATOR);
}
org.springframework.web.bind.ServletRequestParameterPropertyValues

public ServletRequestParameterPropertyValues ServletRequestParameterPropertyValues(ServletRequest request, @Nullable String prefix, @Nullable String prefixSeparator)

{
    super(WebUtils.getParametersStartingWith(request, (prefix != null ? prefix + prefixSeparator : null)));
}

ServletRequestUtils

org.springframework.web.bind.ServletRequestUtils

@Nullable public static Boolean getBooleanParameter(ServletRequest request, String name)

{
    if (request.getParameter(name) == null) {
        return null;
    } 
    return (getRequiredBooleanParameter(request, name));
}
org.springframework.web.bind.ServletRequestUtils

public static boolean getBooleanParameter(ServletRequest request, String name, boolean defaultVal)

{
    if (request.getParameter(name) == null) {
        return defaultVal;
    } 
    try {
        return getRequiredBooleanParameter(request, name);
    } catch (ServletRequestBindingException ex) {
        return defaultVal;
    }
}
org.springframework.web.bind.ServletRequestUtils

public static boolean[] getBooleanParameters(ServletRequest request, String name)

{
    try {
        return getRequiredBooleanParameters(request, name);
    } catch (ServletRequestBindingException ex) {
        return new boolean[0];
    }
}
org.springframework.web.bind.ServletRequestUtils

@Nullable public static Double getDoubleParameter(ServletRequest request, String name)

{
    if (request.getParameter(name) == null) {
        return null;
    } 
    return getRequiredDoubleParameter(request, name);
}
org.springframework.web.bind.ServletRequestUtils

public static double getDoubleParameter(ServletRequest request, String name, double defaultVal)

{
    if (request.getParameter(name) == null) {
        return defaultVal;
    } 
    try {
        return getRequiredDoubleParameter(request, name);
    } catch (ServletRequestBindingException ex) {
        return defaultVal;
    }
}
org.springframework.web.bind.ServletRequestUtils

public static double[] getDoubleParameters(ServletRequest request, String name)

{
    try {
        return getRequiredDoubleParameters(request, name);
    } catch (ServletRequestBindingException ex) {
        return new double[0];
    }
}
org.springframework.web.bind.ServletRequestUtils

@Nullable public static Float getFloatParameter(ServletRequest request, String name)

{
    if (request.getParameter(name) == null) {
        return null;
    } 
    return getRequiredFloatParameter(request, name);
}
org.springframework.web.bind.ServletRequestUtils

public static float getFloatParameter(ServletRequest request, String name, float defaultVal)

{
    if (request.getParameter(name) == null) {
        return defaultVal;
    } 
    try {
        return getRequiredFloatParameter(request, name);
    } catch (ServletRequestBindingException ex) {
        return defaultVal;
    }
}
org.springframework.web.bind.ServletRequestUtils

public static float[] getFloatParameters(ServletRequest request, String name)

{
    try {
        return getRequiredFloatParameters(request, name);
    } catch (ServletRequestBindingException ex) {
        return new float[0];
    }
}
org.springframework.web.bind.ServletRequestUtils

@Nullable public static Integer getIntParameter(ServletRequest request, String name)

{
    if (request.getParameter(name) == null) {
        return null;
    } 
    return getRequiredIntParameter(request, name);
}
org.springframework.web.bind.ServletRequestUtils

public static int getIntParameter(ServletRequest request, String name, int defaultVal)

{
    if (request.getParameter(name) == null) {
        return defaultVal;
    } 
    try {
        return getRequiredIntParameter(request, name);
    } catch (ServletRequestBindingException ex) {
        return defaultVal;
    }
}
org.springframework.web.bind.ServletRequestUtils

public static int[] getIntParameters(ServletRequest request, String name)

{
    try {
        return getRequiredIntParameters(request, name);
    } catch (ServletRequestBindingException ex) {
        return new int[0];
    }
}
org.springframework.web.bind.ServletRequestUtils

@Nullable public static Long getLongParameter(ServletRequest request, String name)

{
    if (request.getParameter(name) == null) {
        return null;
    } 
    return getRequiredLongParameter(request, name);
}
org.springframework.web.bind.ServletRequestUtils

public static long getLongParameter(ServletRequest request, String name, long defaultVal)

{
    if (request.getParameter(name) == null) {
        return defaultVal;
    } 
    try {
        return getRequiredLongParameter(request, name);
    } catch (ServletRequestBindingException ex) {
        return defaultVal;
    }
}
org.springframework.web.bind.ServletRequestUtils

public static long[] getLongParameters(ServletRequest request, String name)

{
    try {
        return getRequiredLongParameters(request, name);
    } catch (ServletRequestBindingException ex) {
        return new long[0];
    }
}
org.springframework.web.bind.ServletRequestUtils

public static boolean getRequiredBooleanParameter(ServletRequest request, String name)

{
    return BOOLEAN_PARSER.parseBoolean(name, request.getParameter(name));
}
org.springframework.web.bind.ServletRequestUtils

public static boolean[] getRequiredBooleanParameters(ServletRequest request, String name)

{
    return BOOLEAN_PARSER.parseBooleans(name, request.getParameterValues(name));
}
org.springframework.web.bind.ServletRequestUtils

public static double getRequiredDoubleParameter(ServletRequest request, String name)

{
    return DOUBLE_PARSER.parseDouble(name, request.getParameter(name));
}
org.springframework.web.bind.ServletRequestUtils

public static double[] getRequiredDoubleParameters(ServletRequest request, String name)

{
    return DOUBLE_PARSER.parseDoubles(name, request.getParameterValues(name));
}
org.springframework.web.bind.ServletRequestUtils

public static float getRequiredFloatParameter(ServletRequest request, String name)

{
    return FLOAT_PARSER.parseFloat(name, request.getParameter(name));
}
org.springframework.web.bind.ServletRequestUtils

public static float[] getRequiredFloatParameters(ServletRequest request, String name)

{
    return FLOAT_PARSER.parseFloats(name, request.getParameterValues(name));
}
org.springframework.web.bind.ServletRequestUtils

public static int getRequiredIntParameter(ServletRequest request, String name)

{
    return INT_PARSER.parseInt(name, request.getParameter(name));
}
org.springframework.web.bind.ServletRequestUtils

public static int[] getRequiredIntParameters(ServletRequest request, String name)

{
    return INT_PARSER.parseInts(name, request.getParameterValues(name));
}
org.springframework.web.bind.ServletRequestUtils

public static long getRequiredLongParameter(ServletRequest request, String name)

{
    return LONG_PARSER.parseLong(name, request.getParameter(name));
}
org.springframework.web.bind.ServletRequestUtils

public static long[] getRequiredLongParameters(ServletRequest request, String name)

{
    return LONG_PARSER.parseLongs(name, request.getParameterValues(name));
}
org.springframework.web.bind.ServletRequestUtils

public static String getRequiredStringParameter(ServletRequest request, String name)

{
    return STRING_PARSER.validateRequiredString(name, request.getParameter(name));
}
org.springframework.web.bind.ServletRequestUtils

public static String[] getRequiredStringParameters(ServletRequest request, String name)

{
    return STRING_PARSER.validateRequiredStrings(name, request.getParameterValues(name));
}
org.springframework.web.bind.ServletRequestUtils

@Nullable public static String getStringParameter(ServletRequest request, String name)

{
    if (request.getParameter(name) == null) {
        return null;
    } 
    return getRequiredStringParameter(request, name);
}
org.springframework.web.bind.ServletRequestUtils

public static String getStringParameter(ServletRequest request, String name, String defaultVal)

{
    String val = request.getParameter(name);
    return (val != null ? val : defaultVal);
}
org.springframework.web.bind.ServletRequestUtils

public static String[] getStringParameters(ServletRequest request, String name)

{
    try {
        return getRequiredStringParameters(request, name);
    } catch (ServletRequestBindingException ex) {
        return new String[0];
    }
}

UnsatisfiedServletRequestParameterException
extends ServletRequestBindingException

org.springframework.web.bind.UnsatisfiedServletRequestParameterException

public UnsatisfiedServletRequestParameterException UnsatisfiedServletRequestParameterException(String[] paramConditions, Map<String, String[]> actualParams)

{
    super("");
    this.paramConditions = Arrays.<String[]>asList(paramConditions);
    this.actualParams = actualParams;
}
org.springframework.web.bind.UnsatisfiedServletRequestParameterException

public UnsatisfiedServletRequestParameterException UnsatisfiedServletRequestParameterException(List<String[]> paramConditions, Map<String, String[]> actualParams)

{
    super("");
    Assert.notEmpty(paramConditions, "Parameter conditions must not be empty");
    this.paramConditions = paramConditions;
    this.actualParams = actualParams;
}
org.springframework.web.bind.UnsatisfiedServletRequestParameterException

public final Map<String, String[]> getActualParams()

{
    return this.actualParams;
}
org.springframework.web.bind.UnsatisfiedServletRequestParameterException

@Override public String getMessage()

{
    StringBuilder sb = new StringBuilder("Parameter conditions ");
    int i = 0;
    for (String[] conditions: this.paramConditions) {
        if (i > 0) {
            sb.append(" OR ");
        } 
        sb.append("\"");
        sb.append(StringUtils.arrayToDelimitedString(conditions, ", "));
        sb.append("\"");
        i++;
    }
    sb.append(" not met for actual request parameters: ");
    sb.append(requestParameterMapToString(this.actualParams));
    return sb.toString();
}
org.springframework.web.bind.UnsatisfiedServletRequestParameterException

public final List<String[]> getParamConditionGroups()

{
    return this.paramConditions;
}
org.springframework.web.bind.UnsatisfiedServletRequestParameterException

public final String[] getParamConditions()

{
    return this.paramConditions.get(0);
}

WebDataBinder
extends DataBinder

org.springframework.web.bind.WebDataBinder

public static final String DEFAULT_FIELD_DEFAULT_PREFIX

org.springframework.web.bind.WebDataBinder

public static final String DEFAULT_FIELD_MARKER_PREFIX

org.springframework.web.bind.WebDataBinder

public WebDataBinder WebDataBinder(@Nullable Object target)

{
    super(target);
}
org.springframework.web.bind.WebDataBinder

public WebDataBinder WebDataBinder(@Nullable Object target, String objectName)

{
    super(target, objectName);
}
org.springframework.web.bind.WebDataBinder

protected void bindMultipart(Map<String, List<MultipartFile>> multipartFiles, MutablePropertyValues mpvs)

{
    multipartFiles.forEach((key, values) -> {
        if (values.size() == 1) {
            MultipartFile value = values.get(0);
            if (isBindEmptyMultipartFiles() || !value.isEmpty()) {
                mpvs.add(key, value);
            } 
        } else {
            mpvs.add(key, values);
        }
    });
}
org.springframework.web.bind.WebDataBinder

@Override protected void doBind(MutablePropertyValues mpvs)

{
    checkFieldDefaults(mpvs);
    checkFieldMarkers(mpvs);
    super.doBind(mpvs);
}
org.springframework.web.bind.WebDataBinder

@Nullable protected Object getEmptyValue(String field, @Nullable Class<?> fieldType)

{
    return (fieldType != null ? getEmptyValue(fieldType) : null);
}
org.springframework.web.bind.WebDataBinder

@Nullable public Object getEmptyValue(Class<?> fieldType)

{
    try {
        if (boolean.class == fieldType || Boolean.class == fieldType) {
            return Boolean.FALSE;
        } else if (fieldType.isArray()) {
            return Array.newInstance(fieldType.getComponentType(), 0);
        } else if (Collection.class.isAssignableFrom(fieldType)) {
            return CollectionFactory.createCollection(fieldType, 0);
        } else if (Map.class.isAssignableFrom(fieldType)) {
            return CollectionFactory.createMap(fieldType, 0);
        } 
    } catch (IllegalArgumentException ex) {
        if (logger.isDebugEnabled()) {
            logger.debug("Failed to create default value - falling back to null: " + ex.getMessage());
        } 
    }
    return null;
}
org.springframework.web.bind.WebDataBinder

@Nullable public String getFieldDefaultPrefix()

{
    return this.fieldDefaultPrefix;
}
org.springframework.web.bind.WebDataBinder

@Nullable public String getFieldMarkerPrefix()

{
    return this.fieldMarkerPrefix;
}
org.springframework.web.bind.WebDataBinder

public boolean isBindEmptyMultipartFiles()

{
    return this.bindEmptyMultipartFiles;
}
org.springframework.web.bind.WebDataBinder

public void setBindEmptyMultipartFiles(boolean bindEmptyMultipartFiles)

{
    this.bindEmptyMultipartFiles = bindEmptyMultipartFiles;
}
org.springframework.web.bind.WebDataBinder

public void setFieldDefaultPrefix(@Nullable String fieldDefaultPrefix)

{
    this.fieldDefaultPrefix = fieldDefaultPrefix;
}
org.springframework.web.bind.WebDataBinder

public void setFieldMarkerPrefix(@Nullable String fieldMarkerPrefix)

{
    this.fieldMarkerPrefix = fieldMarkerPrefix;
}

@ControllerAdvice
org.springframework.web.bind.annotation.ControllerAdvice

@AliasFor("basePackages") private String[] value()

org.springframework.web.bind.annotation.ControllerAdvice

@AliasFor("value") private String[] basePackages()

org.springframework.web.bind.annotation.ControllerAdvice

private Class<?>[] basePackageClasses()

org.springframework.web.bind.annotation.ControllerAdvice

private Class<?>[] assignableTypes()

org.springframework.web.bind.annotation.ControllerAdvice

private Class<?>[] annotations()


@CookieValue
파라미터에 표시
org.springframework.web.bind.annotation.CookieValue

@AliasFor("name") private String value()

org.springframework.web.bind.annotation.CookieValue

@AliasFor("value") private String name()

org.springframework.web.bind.annotation.CookieValue

private boolean required()

org.springframework.web.bind.annotation.CookieValue

private String defaultValue()


@CrossOrigin
org.springframework.web.bind.annotation.CrossOrigin

@Deprecated private String[] DEFAULT_ORIGINS

org.springframework.web.bind.annotation.CrossOrigin

@Deprecated private String[] DEFAULT_ALLOWED_HEADERS

org.springframework.web.bind.annotation.CrossOrigin

@Deprecated private boolean DEFAULT_ALLOW_CREDENTIALS

org.springframework.web.bind.annotation.CrossOrigin

@Deprecated private long DEFAULT_MAX_AGE

org.springframework.web.bind.annotation.CrossOrigin

@AliasFor("origins") private String[] value()

org.springframework.web.bind.annotation.CrossOrigin

@AliasFor("value") private String[] origins()

org.springframework.web.bind.annotation.CrossOrigin

private String[] allowedHeaders()

org.springframework.web.bind.annotation.CrossOrigin

private String[] exposedHeaders()

org.springframework.web.bind.annotation.CrossOrigin

private RequestMethod[] methods()

org.springframework.web.bind.annotation.CrossOrigin

private String allowCredentials()

org.springframework.web.bind.annotation.CrossOrigin

private long maxAge()


@DeleteMapping
함수에 표시
org.springframework.web.bind.annotation.DeleteMapping

@AliasFor(annotation=RequestMapping.class) private String name()

org.springframework.web.bind.annotation.DeleteMapping

@AliasFor(annotation=RequestMapping.class) private String[] value()

org.springframework.web.bind.annotation.DeleteMapping

@AliasFor(annotation=RequestMapping.class) private String[] path()

org.springframework.web.bind.annotation.DeleteMapping

@AliasFor(annotation=RequestMapping.class) private String[] params()

org.springframework.web.bind.annotation.DeleteMapping

@AliasFor(annotation=RequestMapping.class) private String[] headers()

org.springframework.web.bind.annotation.DeleteMapping

@AliasFor(annotation=RequestMapping.class) private String[] consumes()

org.springframework.web.bind.annotation.DeleteMapping

@AliasFor(annotation=RequestMapping.class) private String[] produces()


@ExceptionHandler
함수에 표시
org.springframework.web.bind.annotation.ExceptionHandler

private Class<?>[] value()


@GetMapping
함수에 표시
org.springframework.web.bind.annotation.GetMapping

@AliasFor(annotation=RequestMapping.class) private String name()

org.springframework.web.bind.annotation.GetMapping

@AliasFor(annotation=RequestMapping.class) private String[] value()

org.springframework.web.bind.annotation.GetMapping

@AliasFor(annotation=RequestMapping.class) private String[] path()

org.springframework.web.bind.annotation.GetMapping

@AliasFor(annotation=RequestMapping.class) private String[] params()

org.springframework.web.bind.annotation.GetMapping

@AliasFor(annotation=RequestMapping.class) private String[] headers()

org.springframework.web.bind.annotation.GetMapping

@AliasFor(annotation=RequestMapping.class) private String[] consumes()

org.springframework.web.bind.annotation.GetMapping

@AliasFor(annotation=RequestMapping.class) private String[] produces()


@InitBinder
org.springframework.web.bind.annotation.InitBinder

private String[] value()


@Mapping

@MatrixVariable
파라미터에 표시
org.springframework.web.bind.annotation.MatrixVariable

@AliasFor("name") private String value()

org.springframework.web.bind.annotation.MatrixVariable

@AliasFor("value") private String name()

org.springframework.web.bind.annotation.MatrixVariable

private String pathVar()

org.springframework.web.bind.annotation.MatrixVariable

private boolean required()

org.springframework.web.bind.annotation.MatrixVariable

private String defaultValue()


@ModelAttribute
org.springframework.web.bind.annotation.ModelAttribute

@AliasFor("name") private String value()

org.springframework.web.bind.annotation.ModelAttribute

@AliasFor("value") private String name()

org.springframework.web.bind.annotation.ModelAttribute

private boolean binding()


@PatchMapping
함수에 표시
org.springframework.web.bind.annotation.PatchMapping

@AliasFor(annotation=RequestMapping.class) private String name()

org.springframework.web.bind.annotation.PatchMapping

@AliasFor(annotation=RequestMapping.class) private String[] value()

org.springframework.web.bind.annotation.PatchMapping

@AliasFor(annotation=RequestMapping.class) private String[] path()

org.springframework.web.bind.annotation.PatchMapping

@AliasFor(annotation=RequestMapping.class) private String[] params()

org.springframework.web.bind.annotation.PatchMapping

@AliasFor(annotation=RequestMapping.class) private String[] headers()

org.springframework.web.bind.annotation.PatchMapping

@AliasFor(annotation=RequestMapping.class) private String[] consumes()

org.springframework.web.bind.annotation.PatchMapping

@AliasFor(annotation=RequestMapping.class) private String[] produces()


@PathVariable
파라미터에 표시
org.springframework.web.bind.annotation.PathVariable

@AliasFor("name") private String value()

org.springframework.web.bind.annotation.PathVariable

@AliasFor("value") private String name()

org.springframework.web.bind.annotation.PathVariable

private boolean required()


@PostMapping
함수에 표시
org.springframework.web.bind.annotation.PostMapping

@AliasFor(annotation=RequestMapping.class) private String name()

org.springframework.web.bind.annotation.PostMapping

@AliasFor(annotation=RequestMapping.class) private String[] value()

org.springframework.web.bind.annotation.PostMapping

@AliasFor(annotation=RequestMapping.class) private String[] path()

org.springframework.web.bind.annotation.PostMapping

@AliasFor(annotation=RequestMapping.class) private String[] params()

org.springframework.web.bind.annotation.PostMapping

@AliasFor(annotation=RequestMapping.class) private String[] headers()

org.springframework.web.bind.annotation.PostMapping

@AliasFor(annotation=RequestMapping.class) private String[] consumes()

org.springframework.web.bind.annotation.PostMapping

@AliasFor(annotation=RequestMapping.class) private String[] produces()


@PutMapping
함수에 표시
org.springframework.web.bind.annotation.PutMapping

@AliasFor(annotation=RequestMapping.class) private String name()

org.springframework.web.bind.annotation.PutMapping

@AliasFor(annotation=RequestMapping.class) private String[] value()

org.springframework.web.bind.annotation.PutMapping

@AliasFor(annotation=RequestMapping.class) private String[] path()

org.springframework.web.bind.annotation.PutMapping

@AliasFor(annotation=RequestMapping.class) private String[] params()

org.springframework.web.bind.annotation.PutMapping

@AliasFor(annotation=RequestMapping.class) private String[] headers()

org.springframework.web.bind.annotation.PutMapping

@AliasFor(annotation=RequestMapping.class) private String[] consumes()

org.springframework.web.bind.annotation.PutMapping

@AliasFor(annotation=RequestMapping.class) private String[] produces()


@RequestAttribute
파라미터에 표시
org.springframework.web.bind.annotation.RequestAttribute

@AliasFor("name") private String value()

org.springframework.web.bind.annotation.RequestAttribute

@AliasFor("value") private String name()

org.springframework.web.bind.annotation.RequestAttribute

private boolean required()


@RequestBody
파라미터에 표시
org.springframework.web.bind.annotation.RequestBody

private boolean required()


@RequestHeader
파라미터에 표시
org.springframework.web.bind.annotation.RequestHeader

@AliasFor("name") private String value()

org.springframework.web.bind.annotation.RequestHeader

@AliasFor("value") private String name()

org.springframework.web.bind.annotation.RequestHeader

private boolean required()

org.springframework.web.bind.annotation.RequestHeader

private String defaultValue()


@RequestMapping
org.springframework.web.bind.annotation.RequestMapping

private String name()

org.springframework.web.bind.annotation.RequestMapping

@AliasFor("path") private String[] value()

org.springframework.web.bind.annotation.RequestMapping

@AliasFor("value") private String[] path()

org.springframework.web.bind.annotation.RequestMapping

private RequestMethod[] method()

org.springframework.web.bind.annotation.RequestMapping

private String[] params()

org.springframework.web.bind.annotation.RequestMapping

private String[] headers()

org.springframework.web.bind.annotation.RequestMapping

private String[] consumes()

org.springframework.web.bind.annotation.RequestMapping

private String[] produces()


RequestMethod

enum values
  • GET
  • HEAD
  • POST
  • PUT
  • PATCH
  • DELETE
  • OPTIONS
  • TRACE

@RequestParam
파라미터에 표시
org.springframework.web.bind.annotation.RequestParam

@AliasFor("name") private String value()

org.springframework.web.bind.annotation.RequestParam

@AliasFor("value") private String name()

org.springframework.web.bind.annotation.RequestParam

private boolean required()

org.springframework.web.bind.annotation.RequestParam

private String defaultValue()


@RequestPart
파라미터에 표시
org.springframework.web.bind.annotation.RequestPart

@AliasFor("name") private String value()

org.springframework.web.bind.annotation.RequestPart

@AliasFor("value") private String name()

org.springframework.web.bind.annotation.RequestPart

private boolean required()


@ResponseBody

@ResponseStatus
org.springframework.web.bind.annotation.ResponseStatus

@AliasFor("code") private HttpStatus value()

org.springframework.web.bind.annotation.ResponseStatus

@AliasFor("value") private HttpStatus code()

org.springframework.web.bind.annotation.ResponseStatus

private String reason()


@RestController
org.springframework.web.bind.annotation.RestController

@AliasFor(annotation=Controller.class) private String value()


@RestControllerAdvice
org.springframework.web.bind.annotation.RestControllerAdvice

@AliasFor(annotation=ControllerAdvice.class) private String[] value()

org.springframework.web.bind.annotation.RestControllerAdvice

@AliasFor(annotation=ControllerAdvice.class) private String[] basePackages()

org.springframework.web.bind.annotation.RestControllerAdvice

@AliasFor(annotation=ControllerAdvice.class) private Class<?>[] basePackageClasses()

org.springframework.web.bind.annotation.RestControllerAdvice

@AliasFor(annotation=ControllerAdvice.class) private Class<?>[] assignableTypes()

org.springframework.web.bind.annotation.RestControllerAdvice

@AliasFor(annotation=ControllerAdvice.class) private Class<?>[] annotations()


@SessionAttribute
파라미터에 표시
org.springframework.web.bind.annotation.SessionAttribute

@AliasFor("name") private String value()

org.springframework.web.bind.annotation.SessionAttribute

@AliasFor("value") private String name()

org.springframework.web.bind.annotation.SessionAttribute

private boolean required()


@SessionAttributes
org.springframework.web.bind.annotation.SessionAttributes

@AliasFor("names") private String[] value()

org.springframework.web.bind.annotation.SessionAttributes

@AliasFor("value") private String[] names()

org.springframework.web.bind.annotation.SessionAttributes

private Class<?>[] types()


ValueConstants



ConfigurableWebBindingInitializer
implements WebBindingInitializer

org.springframework.web.bind.support.ConfigurableWebBindingInitializer

@Nullable public final BindingErrorProcessor getBindingErrorProcessor()

{
    return this.bindingErrorProcessor;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer

@Nullable public final ConversionService getConversionService()

{
    return this.conversionService;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer

@Nullable public final MessageCodesResolver getMessageCodesResolver()

{
    return this.messageCodesResolver;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer

@Nullable public final PropertyEditorRegistrar[] getPropertyEditorRegistrars()

{
    return this.propertyEditorRegistrars;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer

@Nullable public final Validator getValidator()

{
    return this.validator;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer

@Override public void initBinder(WebDataBinder binder)

{
    binder.setAutoGrowNestedPaths(this.autoGrowNestedPaths);
    if (this.directFieldAccess) {
        binder.initDirectFieldAccess();
    } 
    if (this.messageCodesResolver != null) {
        binder.setMessageCodesResolver(this.messageCodesResolver);
    } 
    if (this.bindingErrorProcessor != null) {
        binder.setBindingErrorProcessor(this.bindingErrorProcessor);
    } 
    if (this.validator != null && binder.getTarget() != null && this.validator.supports(binder.getTarget().getClass())) {
        binder.setValidator(this.validator);
    } 
    if (this.conversionService != null) {
        binder.setConversionService(this.conversionService);
    } 
    if (this.propertyEditorRegistrars != null) {
        for (PropertyEditorRegistrar propertyEditorRegistrar: this.propertyEditorRegistrars) {
            propertyEditorRegistrar.registerCustomEditors(binder);
        }
    } 
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer

public boolean isAutoGrowNestedPaths()

{
    return this.autoGrowNestedPaths;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer

public boolean isDirectFieldAccess()

{
    return this.directFieldAccess;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer

public void setAutoGrowNestedPaths(boolean autoGrowNestedPaths)

{
    this.autoGrowNestedPaths = autoGrowNestedPaths;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer

public final void setBindingErrorProcessor(@Nullable BindingErrorProcessor bindingErrorProcessor)

{
    this.bindingErrorProcessor = bindingErrorProcessor;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer

public final void setConversionService(@Nullable ConversionService conversionService)

{
    this.conversionService = conversionService;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer

public final void setDirectFieldAccess(boolean directFieldAccess)

{
    this.directFieldAccess = directFieldAccess;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer

public final void setMessageCodesResolver(@Nullable MessageCodesResolver messageCodesResolver)

{
    this.messageCodesResolver = messageCodesResolver;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer

public final void setPropertyEditorRegistrar(PropertyEditorRegistrar propertyEditorRegistrar)

{
    this.propertyEditorRegistrars = new PropertyEditorRegistrar[]{propertyEditorRegistrar};
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer

public final void setPropertyEditorRegistrars(@Nullable PropertyEditorRegistrar[] propertyEditorRegistrars)

{
    this.propertyEditorRegistrars = propertyEditorRegistrars;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer

public final void setValidator(@Nullable Validator validator)

{
    this.validator = validator;
}

DefaultDataBinderFactory
implements WebDataBinderFactory

org.springframework.web.bind.support.DefaultDataBinderFactory

public DefaultDataBinderFactory DefaultDataBinderFactory(@Nullable WebBindingInitializer initializer)

{
    this.initializer = initializer;
}
org.springframework.web.bind.support.DefaultDataBinderFactory

@Override @SuppressWarnings("deprecation") public final WebDataBinder createBinder(NativeWebRequest webRequest, @Nullable Object target, String objectName)

{
    WebDataBinder dataBinder = createBinderInstance(target, objectName, webRequest);
    if (this.initializer != null) {
        this.initializer.initBinder(dataBinder, webRequest);
    } 
    initBinder(dataBinder, webRequest);
    return dataBinder;
}
org.springframework.web.bind.support.DefaultDataBinderFactory

protected WebDataBinder createBinderInstance(@Nullable Object target, String objectName, NativeWebRequest webRequest)

{
    return new WebRequestDataBinder(target, objectName);
}
org.springframework.web.bind.support.DefaultDataBinderFactory

protected void initBinder(WebDataBinder dataBinder, NativeWebRequest webRequest)

{
}

DefaultSessionAttributeStore
implements SessionAttributeStore

org.springframework.web.bind.support.DefaultSessionAttributeStore

protected String getAttributeNameInSession(WebRequest request, String attributeName)

{
    return this.attributeNamePrefix + attributeName;
}
org.springframework.web.bind.support.DefaultSessionAttributeStore

public void setAttributeNamePrefix(@Nullable String attributeNamePrefix)

{
    this.attributeNamePrefix = (attributeNamePrefix != null ? attributeNamePrefix : "");
}

SessionAttributeStore

SessionStatus

SimpleSessionStatus
implements SessionStatus

org.springframework.web.bind.support.SimpleSessionStatus

@Override public boolean isComplete()

{
    return this.complete;
}
org.springframework.web.bind.support.SimpleSessionStatus

@Override public void setComplete()

{
    this.complete = true;
}

SpringWebConstraintValidatorFactory
implements ConstraintValidatorFactory

org.springframework.web.bind.support.SpringWebConstraintValidatorFactory

<T>@Override public T getInstance(Class<T> key)

{
    return getWebApplicationContext().getAutowireCapableBeanFactory().createBean(key);
}
org.springframework.web.bind.support.SpringWebConstraintValidatorFactory

@Override public void releaseInstance(ConstraintValidator<?, ?> instance)

{
    getWebApplicationContext().getAutowireCapableBeanFactory().destroyBean(instance);
}

WebArgumentResolver

WebBindingInitializer

WebDataBinderFactory

WebExchangeBindException
extends ServerWebInputException implements BindingResult

org.springframework.web.bind.support.WebExchangeBindException

public WebExchangeBindException WebExchangeBindException(MethodParameter parameter, BindingResult bindingResult)

{
    super("Validation failure", parameter);
    this.bindingResult = bindingResult;
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public void addAllErrors(Errors errors)

{
    this.bindingResult.addAllErrors(errors);
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public void addError(ObjectError error)

{
    this.bindingResult.addError(error);
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public boolean equals(@Nullable Object other)

{
    return (this == other || this.bindingResult.equals(other));
}
org.springframework.web.bind.support.WebExchangeBindException

@Override @SuppressWarnings("rawtypes") @Nullable public PropertyEditor findEditor(@Nullable String field, @Nullable Class valueType)

{
    return this.bindingResult.findEditor(field, valueType);
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public List<ObjectError> getAllErrors()

{
    return this.bindingResult.getAllErrors();
}
org.springframework.web.bind.support.WebExchangeBindException

public final BindingResult getBindingResult()

{
    return this.bindingResult;
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public int getErrorCount()

{
    return this.bindingResult.getErrorCount();
}
org.springframework.web.bind.support.WebExchangeBindException

@Override @Nullable public FieldError getFieldError()

{
    return this.bindingResult.getFieldError();
}
org.springframework.web.bind.support.WebExchangeBindException

@Override @Nullable public FieldError getFieldError(String field)

{
    return this.bindingResult.getFieldError(field);
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public int getFieldErrorCount()

{
    return this.bindingResult.getFieldErrorCount();
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public int getFieldErrorCount(String field)

{
    return this.bindingResult.getFieldErrorCount(field);
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public List<FieldError> getFieldErrors()

{
    return this.bindingResult.getFieldErrors();
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public List<FieldError> getFieldErrors(String field)

{
    return this.bindingResult.getFieldErrors(field);
}
org.springframework.web.bind.support.WebExchangeBindException

@Override @Nullable public Class<?> getFieldType(String field)

{
    return this.bindingResult.getFieldType(field);
}
org.springframework.web.bind.support.WebExchangeBindException

@Override @Nullable public Object getFieldValue(String field)

{
    return this.bindingResult.getFieldValue(field);
}
org.springframework.web.bind.support.WebExchangeBindException

@Override @Nullable public ObjectError getGlobalError()

{
    return this.bindingResult.getGlobalError();
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public int getGlobalErrorCount()

{
    return this.bindingResult.getGlobalErrorCount();
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public List<ObjectError> getGlobalErrors()

{
    return this.bindingResult.getGlobalErrors();
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public Map<String, Object> getModel()

{
    return this.bindingResult.getModel();
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public String getNestedPath()

{
    return this.bindingResult.getNestedPath();
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public String getObjectName()

{
    return this.bindingResult.getObjectName();
}
org.springframework.web.bind.support.WebExchangeBindException

@Override @Nullable public PropertyEditorRegistry getPropertyEditorRegistry()

{
    return this.bindingResult.getPropertyEditorRegistry();
}
org.springframework.web.bind.support.WebExchangeBindException

@Override @Nullable public Object getRawFieldValue(String field)

{
    return this.bindingResult.getRawFieldValue(field);
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public String[] getSuppressedFields()

{
    return this.bindingResult.getSuppressedFields();
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public Object getTarget()

{
    return this.bindingResult.getTarget();
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public boolean hasErrors()

{
    return this.bindingResult.hasErrors();
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public boolean hasFieldErrors()

{
    return this.bindingResult.hasFieldErrors();
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public boolean hasFieldErrors(String field)

{
    return this.bindingResult.hasFieldErrors(field);
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public boolean hasGlobalErrors()

{
    return this.bindingResult.hasGlobalErrors();
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public int hashCode()

{
    return this.bindingResult.hashCode();
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public void popNestedPath()

{
    this.bindingResult.popNestedPath();
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public void pushNestedPath(String subPath)

{
    this.bindingResult.pushNestedPath(subPath);
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public void recordFieldValue(String field, Class<?> type, @Nullable Object value)

{
    this.bindingResult.recordFieldValue(field, type, value);
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public void recordSuppressedField(String field)

{
    this.bindingResult.recordSuppressedField(field);
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public void reject(String errorCode)

{
    this.bindingResult.reject(errorCode);
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public void reject(String errorCode, String defaultMessage)

{
    this.bindingResult.reject(errorCode, defaultMessage);
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public void reject(String errorCode, @Nullable Object[] errorArgs, @Nullable String defaultMessage)

{
    this.bindingResult.reject(errorCode, errorArgs, defaultMessage);
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public void rejectValue(@Nullable String field, String errorCode)

{
    this.bindingResult.rejectValue(field, errorCode);
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public void rejectValue(@Nullable String field, String errorCode, String defaultMessage)

{
    this.bindingResult.rejectValue(field, errorCode, defaultMessage);
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public void rejectValue(@Nullable String field, String errorCode, @Nullable Object[] errorArgs, @Nullable String defaultMessage)

{
    this.bindingResult.rejectValue(field, errorCode, errorArgs, defaultMessage);
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public String[] resolveMessageCodes(String errorCode)

{
    return this.bindingResult.resolveMessageCodes(errorCode);
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public String[] resolveMessageCodes(String errorCode, String field)

{
    return this.bindingResult.resolveMessageCodes(errorCode, field);
}
org.springframework.web.bind.support.WebExchangeBindException

@Override public void setNestedPath(String nestedPath)

{
    this.bindingResult.setNestedPath(nestedPath);
}

WebExchangeDataBinder
extends WebDataBinder

org.springframework.web.bind.support.WebExchangeDataBinder

public WebExchangeDataBinder WebExchangeDataBinder(@Nullable Object target)

{
    super(target);
}
org.springframework.web.bind.support.WebExchangeDataBinder

public WebExchangeDataBinder WebExchangeDataBinder(@Nullable Object target, String objectName)

{
    super(target, objectName);
}
org.springframework.web.bind.support.WebExchangeDataBinder

public Mono<Void> bind(ServerWebExchange exchange)

{
    return getValuesToBind(exchange).doOnNext(values -> doBind(new MutablePropertyValues(values))).then();
}
org.springframework.web.bind.support.WebExchangeDataBinder

protected Mono<Map<String, Object>> getValuesToBind(ServerWebExchange exchange)

{
    return extractValuesToBind(exchange);
}

WebRequestDataBinder
extends WebDataBinder

org.springframework.web.bind.support.WebRequestDataBinder

public WebRequestDataBinder WebRequestDataBinder(@Nullable Object target)

{
    super(target);
}
org.springframework.web.bind.support.WebRequestDataBinder

public WebRequestDataBinder WebRequestDataBinder(@Nullable Object target, String objectName)

{
    super(target, objectName);
}
org.springframework.web.bind.support.WebRequestDataBinder

public void closeNoCatch()

{
    if (getBindingResult().hasErrors()) {
        throw new BindException(getBindingResult());
    } 
}


AsyncRequestCallback

AsyncRestOperations

AsyncRestTemplate
extends org.springframework.http.client.support.InterceptingAsyncHttpAccessor implements AsyncRestOperations

org.springframework.web.client.AsyncRestTemplate

public AsyncRestTemplate AsyncRestTemplate()

{
    this(new SimpleAsyncTaskExecutor());
}
org.springframework.web.client.AsyncRestTemplate

public AsyncRestTemplate AsyncRestTemplate(org.springframework.http.client.AsyncClientHttpRequestFactory asyncRequestFactory)

{
    this(asyncRequestFactory, (ClientHttpRequestFactory)asyncRequestFactory);
}
org.springframework.web.client.AsyncRestTemplate

public AsyncRestTemplate AsyncRestTemplate(org.springframework.http.client.AsyncClientHttpRequestFactory asyncRequestFactory, ClientHttpRequestFactory syncRequestFactory)

{
    this(asyncRequestFactory, new RestTemplate(syncRequestFactory));
}
org.springframework.web.client.AsyncRestTemplate

public AsyncRestTemplate AsyncRestTemplate(org.springframework.http.client.AsyncClientHttpRequestFactory requestFactory, RestTemplate restTemplate)

{
    Assert.notNull(restTemplate, "RestTemplate must not be null");
    this.syncTemplate = restTemplate;
    setAsyncRequestFactory(requestFactory);
}
org.springframework.web.client.AsyncRestTemplate

<T>protected AsyncRequestCallback acceptHeaderRequestCallback(Class<T> responseType)

{
    return new AsyncRequestCallbackAdapter(this.syncTemplate.acceptHeaderRequestCallback(responseType));
}
org.springframework.web.client.AsyncRestTemplate

@Override public ListenableFuture<?> delete(String url, Object... uriVariables)

{
    return execute(url, HttpMethod.DELETE, null, null, uriVariables);
}
org.springframework.web.client.AsyncRestTemplate

@Override public ListenableFuture<?> delete(String url, Map<String, ?> uriVariables)

{
    return execute(url, HttpMethod.DELETE, null, null, uriVariables);
}
org.springframework.web.client.AsyncRestTemplate

@Override public ListenableFuture<?> delete(URI url)

{
    return execute(url, HttpMethod.DELETE, null, null);
}
org.springframework.web.client.AsyncRestTemplate

<T>protected ListenableFuture<T> doExecute(URI url, HttpMethod method, @Nullable AsyncRequestCallback requestCallback, @Nullable ResponseExtractor<T> responseExtractor)

{
    Assert.notNull(url, "'url' must not be null");
    Assert.notNull(method, "'method' must not be null");
    try {
        org.springframework.http.client.AsyncClientHttpRequest request = createAsyncRequest(url, method);
        if (requestCallback != null) {
            requestCallback.doWithRequest(request);
        } 
        ListenableFuture<ClientHttpResponse> responseFuture = request.executeAsync();
        return new ResponseExtractorFuture<>(method, url, responseFuture, responseExtractor);
    } catch (IOException ex) {
        throw new ResourceAccessException("I/O error on " + method.name() + " request for \"" + url + "\":" + ex.getMessage(), ex);
    }
}
org.springframework.web.client.AsyncRestTemplate

<T>@Override public ListenableFuture<ResponseEntity<T>> exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables)

{
    AsyncRequestCallback requestCallback = httpEntityCallback(requestEntity, responseType);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
    return execute(url, method, requestCallback, responseExtractor, uriVariables);
}
org.springframework.web.client.AsyncRestTemplate

<T>@Override public ListenableFuture<ResponseEntity<T>> exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables)

{
    AsyncRequestCallback requestCallback = httpEntityCallback(requestEntity, responseType);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
    return execute(url, method, requestCallback, responseExtractor, uriVariables);
}
org.springframework.web.client.AsyncRestTemplate

<T>@Override public ListenableFuture<ResponseEntity<T>> exchange(URI url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, Class<T> responseType)

{
    AsyncRequestCallback requestCallback = httpEntityCallback(requestEntity, responseType);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
    return execute(url, method, requestCallback, responseExtractor);
}
org.springframework.web.client.AsyncRestTemplate

<T>@Override public ListenableFuture<ResponseEntity<T>> exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType, Object... uriVariables)

{
    Type type = responseType.getType();
    AsyncRequestCallback requestCallback = httpEntityCallback(requestEntity, type);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(type);
    return execute(url, method, requestCallback, responseExtractor, uriVariables);
}
org.springframework.web.client.AsyncRestTemplate

<T>@Override public ListenableFuture<ResponseEntity<T>> exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables)

{
    Type type = responseType.getType();
    AsyncRequestCallback requestCallback = httpEntityCallback(requestEntity, type);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(type);
    return execute(url, method, requestCallback, responseExtractor, uriVariables);
}
org.springframework.web.client.AsyncRestTemplate

<T>@Override public ListenableFuture<ResponseEntity<T>> exchange(URI url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType)

{
    Type type = responseType.getType();
    AsyncRequestCallback requestCallback = httpEntityCallback(requestEntity, type);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(type);
    return execute(url, method, requestCallback, responseExtractor);
}
org.springframework.web.client.AsyncRestTemplate

<T>@Override public ListenableFuture<T> execute(String url, HttpMethod method, @Nullable AsyncRequestCallback requestCallback, @Nullable ResponseExtractor<T> responseExtractor, Object... uriVariables)

{
    URI expanded = getUriTemplateHandler().expand(url, uriVariables);
    return doExecute(expanded, method, requestCallback, responseExtractor);
}
org.springframework.web.client.AsyncRestTemplate

<T>@Override public ListenableFuture<T> execute(String url, HttpMethod method, @Nullable AsyncRequestCallback requestCallback, @Nullable ResponseExtractor<T> responseExtractor, Map<String, ?> uriVariables)

{
    URI expanded = getUriTemplateHandler().expand(url, uriVariables);
    return doExecute(expanded, method, requestCallback, responseExtractor);
}
org.springframework.web.client.AsyncRestTemplate

<T>@Override public ListenableFuture<T> execute(URI url, HttpMethod method, @Nullable AsyncRequestCallback requestCallback, @Nullable ResponseExtractor<T> responseExtractor)

{
    return doExecute(url, method, requestCallback, responseExtractor);
}
org.springframework.web.client.AsyncRestTemplate

public ResponseErrorHandler getErrorHandler()

{
    return this.syncTemplate.getErrorHandler();
}
org.springframework.web.client.AsyncRestTemplate

<T>@Override public ListenableFuture<ResponseEntity<T>> getForEntity(String url, Class<T> responseType, Map<String, ?> uriVariables)

{
    AsyncRequestCallback requestCallback = acceptHeaderRequestCallback(responseType);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
    return execute(url, HttpMethod.GET, requestCallback, responseExtractor, uriVariables);
}
org.springframework.web.client.AsyncRestTemplate

public List<HttpMessageConverter<?>> getMessageConverters()

{
    return this.syncTemplate.getMessageConverters();
}
org.springframework.web.client.AsyncRestTemplate

@Override public RestOperations getRestOperations()

{
    return this.syncTemplate;
}
org.springframework.web.client.AsyncRestTemplate

public UriTemplateHandler getUriTemplateHandler()

{
    return this.syncTemplate.getUriTemplateHandler();
}
org.springframework.web.client.AsyncRestTemplate

@Override public ListenableFuture<HttpHeaders> headForHeaders(String url, Object... uriVariables)

{
    ResponseExtractor<HttpHeaders> headersExtractor = headersExtractor();
    return execute(url, HttpMethod.HEAD, null, headersExtractor, uriVariables);
}
org.springframework.web.client.AsyncRestTemplate

@Override public ListenableFuture<HttpHeaders> headForHeaders(String url, Map<String, ?> uriVariables)

{
    ResponseExtractor<HttpHeaders> headersExtractor = headersExtractor();
    return execute(url, HttpMethod.HEAD, null, headersExtractor, uriVariables);
}
org.springframework.web.client.AsyncRestTemplate

@Override public ListenableFuture<HttpHeaders> headForHeaders(URI url)

{
    ResponseExtractor<HttpHeaders> headersExtractor = headersExtractor();
    return execute(url, HttpMethod.HEAD, null, headersExtractor);
}
org.springframework.web.client.AsyncRestTemplate

protected ResponseExtractor<HttpHeaders> headersExtractor()

{
    return this.syncTemplate.headersExtractor();
}
org.springframework.web.client.AsyncRestTemplate

<T>protected AsyncRequestCallback httpEntityCallback(@Nullable HttpEntity<T> requestBody)

{
    return new AsyncRequestCallbackAdapter(this.syncTemplate.httpEntityCallback(requestBody));
}
org.springframework.web.client.AsyncRestTemplate

<T>protected AsyncRequestCallback httpEntityCallback(@Nullable HttpEntity<T> request, Type responseType)

{
    return new AsyncRequestCallbackAdapter(this.syncTemplate.httpEntityCallback(request, responseType));
}
org.springframework.web.client.AsyncRestTemplate

@Override public ListenableFuture<Set<HttpMethod>> optionsForAllow(String url, Object... uriVars)

{
    ResponseExtractor<HttpHeaders> extractor = headersExtractor();
    ListenableFuture<HttpHeaders> future = execute(url, HttpMethod.OPTIONS, null, extractor, uriVars);
    return adaptToAllowHeader(future);
}
org.springframework.web.client.AsyncRestTemplate

@Override public ListenableFuture<Set<HttpMethod>> optionsForAllow(String url, Map<String, ?> uriVars)

{
    ResponseExtractor<HttpHeaders> extractor = headersExtractor();
    ListenableFuture<HttpHeaders> future = execute(url, HttpMethod.OPTIONS, null, extractor, uriVars);
    return adaptToAllowHeader(future);
}
org.springframework.web.client.AsyncRestTemplate

<T>@Override public ListenableFuture<ResponseEntity<T>> postForEntity(String url, @Nullable HttpEntity<?> request, Class<T> responseType, Object... uriVariables)

{
    AsyncRequestCallback requestCallback = httpEntityCallback(request, responseType);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
    return execute(url, HttpMethod.POST, requestCallback, responseExtractor, uriVariables);
}
org.springframework.web.client.AsyncRestTemplate

<T>@Override public ListenableFuture<ResponseEntity<T>> postForEntity(String url, @Nullable HttpEntity<?> request, Class<T> responseType, Map<String, ?> uriVariables)

{
    AsyncRequestCallback requestCallback = httpEntityCallback(request, responseType);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
    return execute(url, HttpMethod.POST, requestCallback, responseExtractor, uriVariables);
}
org.springframework.web.client.AsyncRestTemplate

<T>@Override public ListenableFuture<ResponseEntity<T>> postForEntity(URI url, @Nullable HttpEntity<?> request, Class<T> responseType)

{
    AsyncRequestCallback requestCallback = httpEntityCallback(request, responseType);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
    return execute(url, HttpMethod.POST, requestCallback, responseExtractor);
}
org.springframework.web.client.AsyncRestTemplate

@Override public ListenableFuture<?> put(String url, @Nullable HttpEntity<?> request, Object... uriVars)

{
    AsyncRequestCallback requestCallback = httpEntityCallback(request);
    return execute(url, HttpMethod.PUT, requestCallback, null, uriVars);
}
org.springframework.web.client.AsyncRestTemplate

@Override public ListenableFuture<?> put(String url, @Nullable HttpEntity<?> request, Map<String, ?> uriVars)

{
    AsyncRequestCallback requestCallback = httpEntityCallback(request);
    return execute(url, HttpMethod.PUT, requestCallback, null, uriVars);
}
org.springframework.web.client.AsyncRestTemplate

@Override public ListenableFuture<?> put(URI url, @Nullable HttpEntity<?> request)

{
    AsyncRequestCallback requestCallback = httpEntityCallback(request);
    return execute(url, HttpMethod.PUT, requestCallback, null);
}
org.springframework.web.client.AsyncRestTemplate

<T>protected ResponseExtractor<ResponseEntity<T>> responseEntityExtractor(Type responseType)

{
    return this.syncTemplate.responseEntityExtractor(responseType);
}
org.springframework.web.client.AsyncRestTemplate

public void setErrorHandler(ResponseErrorHandler errorHandler)

{
    this.syncTemplate.setErrorHandler(errorHandler);
}
org.springframework.web.client.AsyncRestTemplate

public void setMessageConverters(List<HttpMessageConverter<?>> messageConverters)

{
    this.syncTemplate.setMessageConverters(messageConverters);
}
org.springframework.web.client.AsyncRestTemplate

public void setUriTemplateHandler(UriTemplateHandler handler)

{
    this.syncTemplate.setUriTemplateHandler(handler);
}

DefaultResponseErrorHandler
implements ResponseErrorHandler

org.springframework.web.client.DefaultResponseErrorHandler

@Nullable protected Charset getCharset(ClientHttpResponse response)

{
    HttpHeaders headers = response.getHeaders();
    MediaType contentType = headers.getContentType();
    return (contentType != null ? contentType.getCharset() : null);
}
org.springframework.web.client.DefaultResponseErrorHandler

protected byte[] getResponseBody(ClientHttpResponse response)

{
    try {
        return FileCopyUtils.copyToByteArray(response.getBody());
    } catch (IOException ex) {
    }
    return new byte[0];
}
org.springframework.web.client.DefaultResponseErrorHandler

protected boolean hasError(HttpStatus statusCode)

{
    return statusCode.isError();
}

ExtractingResponseErrorHandler
extends DefaultResponseErrorHandler

org.springframework.web.client.ExtractingResponseErrorHandler

public ExtractingResponseErrorHandler ExtractingResponseErrorHandler()

{
}
org.springframework.web.client.ExtractingResponseErrorHandler

public ExtractingResponseErrorHandler ExtractingResponseErrorHandler(List<HttpMessageConverter<?>> messageConverters)

{
    this.messageConverters = messageConverters;
}
org.springframework.web.client.ExtractingResponseErrorHandler

@Override public void handleError(ClientHttpResponse response, HttpStatus statusCode)

{
    if (this.statusMapping.containsKey(statusCode)) {
        extract(this.statusMapping.get(statusCode), response);
    } else if (this.seriesMapping.containsKey(statusCode.series())) {
        extract(this.seriesMapping.get(statusCode.series()), response);
    } else {
        super.handleError(response, statusCode);
    }
}
org.springframework.web.client.ExtractingResponseErrorHandler

@Override protected boolean hasError(HttpStatus statusCode)

{
    if (this.statusMapping.containsKey(statusCode)) {
        return this.statusMapping.get(statusCode) != null;
    } else if (this.seriesMapping.containsKey(statusCode.series())) {
        return this.seriesMapping.get(statusCode.series()) != null;
    } else {
        return super.hasError(statusCode);
    }
}
org.springframework.web.client.ExtractingResponseErrorHandler

public void setMessageConverters(List<HttpMessageConverter<?>> messageConverters)

{
    this.messageConverters = messageConverters;
}
org.springframework.web.client.ExtractingResponseErrorHandler

public void setSeriesMapping(Map<HttpStatus.Series, Class<?>> seriesMapping)

{
    if (!CollectionUtils.isEmpty(seriesMapping)) {
        this.seriesMapping.putAll(seriesMapping);
    } 
}
org.springframework.web.client.ExtractingResponseErrorHandler

public void setStatusMapping(Map<HttpStatus, Class<?>> statusMapping)

{
    if (!CollectionUtils.isEmpty(statusMapping)) {
        this.statusMapping.putAll(statusMapping);
    } 
}

HttpClientErrorException
extends HttpStatusCodeException

BadRequest
extends HttpClientErrorException

Conflict
extends HttpClientErrorException

Forbidden
extends HttpClientErrorException

Gone
extends HttpClientErrorException

org.springframework.web.client.HttpClientErrorException

public HttpClientErrorException HttpClientErrorException(HttpStatus statusCode)

{
    super(statusCode);
}
org.springframework.web.client.HttpClientErrorException

public HttpClientErrorException HttpClientErrorException(HttpStatus statusCode, String statusText)

{
    super(statusCode, statusText);
}
org.springframework.web.client.HttpClientErrorException

public HttpClientErrorException HttpClientErrorException(HttpStatus statusCode, String statusText, @Nullable byte[] body, @Nullable Charset responseCharset)

{
    super(statusCode, statusText, body, responseCharset);
}
org.springframework.web.client.HttpClientErrorException

public HttpClientErrorException HttpClientErrorException(HttpStatus statusCode, String statusText, @Nullable HttpHeaders headers, @Nullable byte[] body, @Nullable Charset responseCharset)

{
    super(statusCode, statusText, headers, body, responseCharset);
}
MethodNotAllowed
extends HttpClientErrorException

NotAcceptable
extends HttpClientErrorException

NotFound
extends HttpClientErrorException

TooManyRequests
extends HttpClientErrorException

Unauthorized
extends HttpClientErrorException

UnprocessableEntity
extends HttpClientErrorException

UnsupportedMediaType
extends HttpClientErrorException


HttpMessageConverterExtractor<T>
implements ResponseExtractor<T>

org.springframework.web.client.HttpMessageConverterExtractor

public HttpMessageConverterExtractor HttpMessageConverterExtractor(Class<T> responseType, List<HttpMessageConverter<?>> messageConverters)

{
    this((Type)responseType, messageConverters);
}
org.springframework.web.client.HttpMessageConverterExtractor

public HttpMessageConverterExtractor HttpMessageConverterExtractor(Type responseType, List<HttpMessageConverter<?>> messageConverters)

{
    this(responseType, messageConverters, LogFactory.getLog(HttpMessageConverterExtractor.class));
}
org.springframework.web.client.HttpMessageConverterExtractor

@Override @SuppressWarnings({"unchecked","rawtypes","resource"}) public T extractData(ClientHttpResponse response)

{
    MessageBodyClientHttpResponseWrapper responseWrapper = new MessageBodyClientHttpResponseWrapper(response);
    if (!responseWrapper.hasMessageBody() || responseWrapper.hasEmptyMessageBody()) {
        return null;
    } 
    MediaType contentType = getContentType(responseWrapper);
    try {
        for (HttpMessageConverter<?> messageConverter: this.messageConverters) {
            if (messageConverter instanceof GenericHttpMessageConverter) {
                GenericHttpMessageConverter<?> genericMessageConverter = (GenericHttpMessageConverter<?>)messageConverter;
                if (genericMessageConverter.canRead(this.responseType, null, contentType)) {
                    if (logger.isDebugEnabled()) {
                        ResolvableType resolvableType = ResolvableType.forType(this.responseType);
                        logger.debug("Reading to [" + resolvableType + "]");
                    } 
                    return (T)genericMessageConverter.read(this.responseType, null, responseWrapper);
                } 
            } 
            if (this.responseClass != null) {
                if (messageConverter.canRead(this.responseClass, contentType)) {
                    if (logger.isDebugEnabled()) {
                        String className = this.responseClass.getName();
                        logger.debug("Reading to [" + className + "] as \"" + contentType + "\"");
                    } 
                    return (T)messageConverter.read((Class)this.responseClass, responseWrapper);
                } 
            } 
        }
    } catch (IOException | HttpMessageNotReadableException ex) {
        throw new RestClientException("Error while extracting response for type [" + this.responseType + "] and content type [" + contentType + "]", ex);
    }
    throw new RestClientException("Could not extract response: no suitable HttpMessageConverter found " + "for response type [" + this.responseType + "] and content type [" + contentType + "]");
}
org.springframework.web.client.HttpMessageConverterExtractor

@Nullable protected MediaType getContentType(ClientHttpResponse response)

{
    MediaType contentType = response.getHeaders().getContentType();
    if (contentType == null) {
        if (logger.isTraceEnabled()) {
            logger.trace("No content-type, using 'application/octet-stream'");
        } 
        contentType = MediaType.APPLICATION_OCTET_STREAM;
    } 
    return contentType;
}

HttpServerErrorException
extends HttpStatusCodeException

BadGateway
extends HttpServerErrorException

GatewayTimeout
extends HttpServerErrorException

org.springframework.web.client.HttpServerErrorException

public HttpServerErrorException HttpServerErrorException(HttpStatus statusCode)

{
    super(statusCode);
}
org.springframework.web.client.HttpServerErrorException

public HttpServerErrorException HttpServerErrorException(HttpStatus statusCode, String statusText)

{
    super(statusCode, statusText);
}
org.springframework.web.client.HttpServerErrorException

public HttpServerErrorException HttpServerErrorException(HttpStatus statusCode, String statusText, @Nullable byte[] body, @Nullable Charset charset)

{
    super(statusCode, statusText, body, charset);
}
org.springframework.web.client.HttpServerErrorException

public HttpServerErrorException HttpServerErrorException(HttpStatus statusCode, String statusText, @Nullable HttpHeaders headers, @Nullable byte[] body, @Nullable Charset charset)

{
    super(statusCode, statusText, headers, body, charset);
}
InternalServerError
extends HttpServerErrorException

NotImplemented
extends HttpServerErrorException

ServiceUnavailable
extends HttpServerErrorException


HttpStatusCodeException
extends RestClientResponseException

org.springframework.web.client.HttpStatusCodeException

protected HttpStatusCodeException HttpStatusCodeException(HttpStatus statusCode)

{
    this(statusCode, statusCode.name(), null, null, null);
}
org.springframework.web.client.HttpStatusCodeException

protected HttpStatusCodeException HttpStatusCodeException(HttpStatus statusCode, String statusText)

{
    this(statusCode, statusText, null, null, null);
}
org.springframework.web.client.HttpStatusCodeException

protected HttpStatusCodeException HttpStatusCodeException(HttpStatus statusCode, String statusText, @Nullable byte[] responseBody, @Nullable Charset responseCharset)

{
    this(statusCode, statusText, null, responseBody, responseCharset);
}
org.springframework.web.client.HttpStatusCodeException

protected HttpStatusCodeException HttpStatusCodeException(HttpStatus statusCode, String statusText, @Nullable HttpHeaders responseHeaders, @Nullable byte[] responseBody, @Nullable Charset responseCharset)

{
    super(getMessage(statusCode, statusText), statusCode.value(), statusText, responseHeaders, responseBody, responseCharset);
    this.statusCode = statusCode;
}
org.springframework.web.client.HttpStatusCodeException

public HttpStatus getStatusCode()

{
    return this.statusCode;
}

MessageBodyClientHttpResponseWrapper
implements ClientHttpResponse

org.springframework.web.client.MessageBodyClientHttpResponseWrapper

public MessageBodyClientHttpResponseWrapper MessageBodyClientHttpResponseWrapper(ClientHttpResponse response)

{
    this.response = response;
}
org.springframework.web.client.MessageBodyClientHttpResponseWrapper

@Override public void close()

{
    this.response.close();
}
org.springframework.web.client.MessageBodyClientHttpResponseWrapper

@Override public InputStream getBody()

{
    return (this.pushbackInputStream != null ? this.pushbackInputStream : this.response.getBody());
}
org.springframework.web.client.MessageBodyClientHttpResponseWrapper

@Override public HttpHeaders getHeaders()

{
    return this.response.getHeaders();
}
org.springframework.web.client.MessageBodyClientHttpResponseWrapper

@Override public int getRawStatusCode()

{
    return this.response.getRawStatusCode();
}
org.springframework.web.client.MessageBodyClientHttpResponseWrapper

@Override public HttpStatus getStatusCode()

{
    return this.response.getStatusCode();
}
org.springframework.web.client.MessageBodyClientHttpResponseWrapper

@Override public String getStatusText()

{
    return this.response.getStatusText();
}
org.springframework.web.client.MessageBodyClientHttpResponseWrapper

public boolean hasMessageBody()

{
    HttpStatus status = HttpStatus.resolve(getRawStatusCode());
    if (status != null && (status.is1xxInformational() || status == HttpStatus.NO_CONTENT || status == HttpStatus.NOT_MODIFIED)) {
        return false;
    } 
    if (getHeaders().getContentLength() == 0) {
        return false;
    } 
    return true;
}

RequestCallback

ResourceAccessException
extends RestClientException

org.springframework.web.client.ResourceAccessException

public ResourceAccessException ResourceAccessException(String msg)

{
    super(msg);
}
org.springframework.web.client.ResourceAccessException

public ResourceAccessException ResourceAccessException(String msg, IOException ex)

{
    super(msg, ex);
}

ResponseErrorHandler

ResponseExtractor

RestClientException
extends NestedRuntimeException

org.springframework.web.client.RestClientException

public RestClientException RestClientException(String msg)

{
    super(msg);
}
org.springframework.web.client.RestClientException

public RestClientException RestClientException(String msg, Throwable ex)

{
    super(msg, ex);
}

RestClientResponseException
extends RestClientException

org.springframework.web.client.RestClientResponseException

public RestClientResponseException RestClientResponseException(String message, int statusCode, String statusText, @Nullable HttpHeaders responseHeaders, @Nullable byte[] responseBody, @Nullable Charset responseCharset)

{
    super(message);
    this.rawStatusCode = statusCode;
    this.statusText = statusText;
    this.responseHeaders = responseHeaders;
    this.responseBody = (responseBody != null ? responseBody : new byte[0]);
    this.responseCharset = (responseCharset != null ? responseCharset.name() : null);
}
org.springframework.web.client.RestClientResponseException

public int getRawStatusCode()

{
    return this.rawStatusCode;
}
org.springframework.web.client.RestClientResponseException

public byte[] getResponseBodyAsByteArray()

{
    return this.responseBody;
}
org.springframework.web.client.RestClientResponseException

public String getResponseBodyAsString()

{
    if (this.responseCharset == null) {
        return new String(this.responseBody, DEFAULT_CHARSET);
    } 
    try {
        return new String(this.responseBody, this.responseCharset);
    } catch (UnsupportedEncodingException ex) {
        throw new IllegalStateException(ex);
    }
}
org.springframework.web.client.RestClientResponseException

@Nullable public HttpHeaders getResponseHeaders()

{
    return this.responseHeaders;
}
org.springframework.web.client.RestClientResponseException

public String getStatusText()

{
    return this.statusText;
}

RestOperations

RestTemplate
extends InterceptingHttpAccessor implements RestOperations

org.springframework.web.client.RestTemplate

public RestTemplate RestTemplate(ClientHttpRequestFactory requestFactory)

{
    this();
    setRequestFactory(requestFactory);
}
org.springframework.web.client.RestTemplate

public RestTemplate RestTemplate(List<HttpMessageConverter<?>> messageConverters)

{
    validateConverters(messageConverters);
    this.messageConverters.addAll(messageConverters);
    this.uriTemplateHandler = initUriTemplateHandler();
}
org.springframework.web.client.RestTemplate

<T>public RequestCallback acceptHeaderRequestCallback(Class<T> responseType)

{
    return new AcceptHeaderRequestCallback(responseType);
}
org.springframework.web.client.RestTemplate

@Override public void delete(String url, Object... uriVariables)

{
    execute(url, HttpMethod.DELETE, null, null, uriVariables);
}
org.springframework.web.client.RestTemplate

@Override public void delete(String url, Map<String, ?> uriVariables)

{
    execute(url, HttpMethod.DELETE, null, null, uriVariables);
}
org.springframework.web.client.RestTemplate

@Override public void delete(URI url)

{
    execute(url, HttpMethod.DELETE, null, null);
}
org.springframework.web.client.RestTemplate

<T>@Nullable protected T doExecute(URI url, @Nullable HttpMethod method, @Nullable RequestCallback requestCallback, @Nullable ResponseExtractor<T> responseExtractor)

{
    Assert.notNull(url, "URI is required");
    Assert.notNull(method, "HttpMethod is required");
    ClientHttpResponse response = null;
    try {
        ClientHttpRequest request = createRequest(url, method);
        if (requestCallback != null) {
            requestCallback.doWithRequest(request);
        } 
        response = request.execute();
        handleResponse(url, method, response);
        return (responseExtractor != null ? responseExtractor.extractData(response) : null);
    } catch (IOException ex) {
        String resource = url.toString();
        String query = url.getRawQuery();
        resource = (query != null ? resource.substring(0, resource.indexOf('?')) : resource);
        throw new ResourceAccessException("I/O error on " + method.name() + " request for \"" + resource + "\": " + ex.getMessage(), ex);
    } finally {
        if (response != null) {
            response.close();
        } 
    }
}
org.springframework.web.client.RestTemplate

<T>@Override public ResponseEntity<T> exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables)

{
    RequestCallback requestCallback = httpEntityCallback(requestEntity, responseType);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
    return nonNull(execute(url, method, requestCallback, responseExtractor, uriVariables));
}
org.springframework.web.client.RestTemplate

<T>@Override public ResponseEntity<T> exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables)

{
    RequestCallback requestCallback = httpEntityCallback(requestEntity, responseType);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
    return nonNull(execute(url, method, requestCallback, responseExtractor, uriVariables));
}
org.springframework.web.client.RestTemplate

<T>@Override public ResponseEntity<T> exchange(URI url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, Class<T> responseType)

{
    RequestCallback requestCallback = httpEntityCallback(requestEntity, responseType);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
    return nonNull(execute(url, method, requestCallback, responseExtractor));
}
org.springframework.web.client.RestTemplate

<T>@Override public ResponseEntity<T> exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType, Object... uriVariables)

{
    Type type = responseType.getType();
    RequestCallback requestCallback = httpEntityCallback(requestEntity, type);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(type);
    return nonNull(execute(url, method, requestCallback, responseExtractor, uriVariables));
}
org.springframework.web.client.RestTemplate

<T>@Override public ResponseEntity<T> exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables)

{
    Type type = responseType.getType();
    RequestCallback requestCallback = httpEntityCallback(requestEntity, type);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(type);
    return nonNull(execute(url, method, requestCallback, responseExtractor, uriVariables));
}
org.springframework.web.client.RestTemplate

<T>@Override public ResponseEntity<T> exchange(URI url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType)

{
    Type type = responseType.getType();
    RequestCallback requestCallback = httpEntityCallback(requestEntity, type);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(type);
    return nonNull(execute(url, method, requestCallback, responseExtractor));
}
org.springframework.web.client.RestTemplate

<T>@Override @Nullable public T execute(String url, HttpMethod method, @Nullable RequestCallback requestCallback, @Nullable ResponseExtractor<T> responseExtractor, Object... uriVariables)

{
    URI expanded = getUriTemplateHandler().expand(url, uriVariables);
    return doExecute(expanded, method, requestCallback, responseExtractor);
}
org.springframework.web.client.RestTemplate

<T>@Override @Nullable public T execute(String url, HttpMethod method, @Nullable RequestCallback requestCallback, @Nullable ResponseExtractor<T> responseExtractor, Map<String, ?> uriVariables)

{
    URI expanded = getUriTemplateHandler().expand(url, uriVariables);
    return doExecute(expanded, method, requestCallback, responseExtractor);
}
org.springframework.web.client.RestTemplate

<T>@Override @Nullable public T execute(URI url, HttpMethod method, @Nullable RequestCallback requestCallback, @Nullable ResponseExtractor<T> responseExtractor)

{
    return doExecute(url, method, requestCallback, responseExtractor);
}
org.springframework.web.client.RestTemplate

public ResponseErrorHandler getErrorHandler()

{
    return this.errorHandler;
}
org.springframework.web.client.RestTemplate

public List<HttpMessageConverter<?>> getMessageConverters()

{
    return this.messageConverters;
}
org.springframework.web.client.RestTemplate

public UriTemplateHandler getUriTemplateHandler()

{
    return this.uriTemplateHandler;
}
org.springframework.web.client.RestTemplate

@Override public HttpHeaders headForHeaders(String url, Object... uriVariables)

{
    return nonNull(execute(url, HttpMethod.HEAD, null, headersExtractor(), uriVariables));
}
org.springframework.web.client.RestTemplate

@Override public HttpHeaders headForHeaders(String url, Map<String, ?> uriVariables)

{
    return nonNull(execute(url, HttpMethod.HEAD, null, headersExtractor(), uriVariables));
}
org.springframework.web.client.RestTemplate

@Override public HttpHeaders headForHeaders(URI url)

{
    return nonNull(execute(url, HttpMethod.HEAD, null, headersExtractor()));
}
org.springframework.web.client.RestTemplate

protected ResponseExtractor<HttpHeaders> headersExtractor()

{
    return this.headersExtractor;
}
org.springframework.web.client.RestTemplate

<T>public RequestCallback httpEntityCallback(@Nullable Object requestBody)

{
    return new HttpEntityRequestCallback(requestBody);
}
org.springframework.web.client.RestTemplate

<T>public RequestCallback httpEntityCallback(@Nullable Object requestBody, Type responseType)

{
    return new HttpEntityRequestCallback(requestBody, responseType);
}
org.springframework.web.client.RestTemplate

<T>@Override public ResponseEntity<T> postForEntity(String url, @Nullable Object request, Class<T> responseType, Map<String, ?> uriVariables)

{
    RequestCallback requestCallback = httpEntityCallback(request, responseType);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
    return nonNull(execute(url, HttpMethod.POST, requestCallback, responseExtractor, uriVariables));
}
org.springframework.web.client.RestTemplate

@Override @Nullable public URI postForLocation(String url, @Nullable Object request, Map<String, ?> uriVariables)

{
    RequestCallback requestCallback = httpEntityCallback(request);
    HttpHeaders headers = execute(url, HttpMethod.POST, requestCallback, headersExtractor(), uriVariables);
    return (headers != null ? headers.getLocation() : null);
}
org.springframework.web.client.RestTemplate

@Override public void put(String url, @Nullable Object request, Object... uriVariables)

{
    RequestCallback requestCallback = httpEntityCallback(request);
    execute(url, HttpMethod.PUT, requestCallback, null, uriVariables);
}
org.springframework.web.client.RestTemplate

@Override public void put(String url, @Nullable Object request, Map<String, ?> uriVariables)

{
    RequestCallback requestCallback = httpEntityCallback(request);
    execute(url, HttpMethod.PUT, requestCallback, null, uriVariables);
}
org.springframework.web.client.RestTemplate

@Override public void put(URI url, @Nullable Object request)

{
    RequestCallback requestCallback = httpEntityCallback(request);
    execute(url, HttpMethod.PUT, requestCallback, null);
}
org.springframework.web.client.RestTemplate

<T>public ResponseExtractor<ResponseEntity<T>> responseEntityExtractor(Type responseType)

{
    return new ResponseEntityResponseExtractor<>(responseType);
}
org.springframework.web.client.RestTemplate

public void setErrorHandler(ResponseErrorHandler errorHandler)

{
    Assert.notNull(errorHandler, "ResponseErrorHandler must not be null");
    this.errorHandler = errorHandler;
}
org.springframework.web.client.RestTemplate

public void setMessageConverters(List<HttpMessageConverter<?>> messageConverters)

{
    validateConverters(messageConverters);
    if (this.messageConverters != messageConverters) {
        this.messageConverters.clear();
        this.messageConverters.addAll(messageConverters);
    } 
}
org.springframework.web.client.RestTemplate

public void setUriTemplateHandler(UriTemplateHandler handler)

{
    Assert.notNull(handler, "UriTemplateHandler must not be null");
    this.uriTemplateHandler = handler;
}

UnknownHttpStatusCodeException
extends RestClientResponseException

org.springframework.web.client.UnknownHttpStatusCodeException

public UnknownHttpStatusCodeException UnknownHttpStatusCodeException(int rawStatusCode, String statusText, @Nullable HttpHeaders responseHeaders, @Nullable byte[] responseBody, @Nullable Charset responseCharset)

{
    super("Unknown status code [" + rawStatusCode + "]" + " " + statusText, rawStatusCode, statusText, responseHeaders, responseBody, responseCharset);
}


RestGatewaySupport

org.springframework.web.client.support.RestGatewaySupport

public RestGatewaySupport RestGatewaySupport()

{
    this.restTemplate = new RestTemplate();
}
org.springframework.web.client.support.RestGatewaySupport

public RestGatewaySupport RestGatewaySupport(ClientHttpRequestFactory requestFactory)

{
    Assert.notNull(requestFactory, "'requestFactory' must not be null");
    this.restTemplate = new RestTemplate(requestFactory);
}
org.springframework.web.client.support.RestGatewaySupport

public RestTemplate getRestTemplate()

{
    return this.restTemplate;
}
org.springframework.web.client.support.RestGatewaySupport

protected final Log logger

org.springframework.web.client.support.RestGatewaySupport

public void setRestTemplate(RestTemplate restTemplate)

{
    Assert.notNull(restTemplate, "'restTemplate' must not be null");
    this.restTemplate = restTemplate;
}


AbstractContextLoaderInitializer
implements WebApplicationInitializer

org.springframework.web.context.AbstractContextLoaderInitializer

@Nullable protected abstract WebApplicationContext createRootApplicationContext()

org.springframework.web.context.AbstractContextLoaderInitializer

@Nullable protected ApplicationContextInitializer<?>[] getRootApplicationContextInitializers()

{
    return null;
}
org.springframework.web.context.AbstractContextLoaderInitializer

protected final Log logger

org.springframework.web.context.AbstractContextLoaderInitializer

@Override public void onStartup(ServletContext servletContext)

{
    registerContextLoaderListener(servletContext);
}

ConfigurableWebApplicationContext
inherit classes
  • WebApplicationContext
  • ConfigurableApplicationContext

ConfigurableWebEnvironment
inherit classes
  • ConfigurableEnvironment

ContextCleanupListener
implements ServletContextListener

org.springframework.web.context.ContextCleanupListener

@Override public void contextDestroyed(ServletContextEvent event)

{
    cleanupAttributes(event.getServletContext());
}
org.springframework.web.context.ContextCleanupListener

@Override public void contextInitialized(ServletContextEvent event)

{
}

ContextLoader

org.springframework.web.context.ContextLoader

public static final String CONFIG_LOCATION_PARAM

org.springframework.web.context.ContextLoader

public static final String CONTEXT_CLASS_PARAM

org.springframework.web.context.ContextLoader

public static final String CONTEXT_ID_PARAM

org.springframework.web.context.ContextLoader

public static final String CONTEXT_INITIALIZER_CLASSES_PARAM

org.springframework.web.context.ContextLoader

public ContextLoader ContextLoader()

{
}
org.springframework.web.context.ContextLoader

public ContextLoader ContextLoader(WebApplicationContext context)

{
    this.context = context;
}
org.springframework.web.context.ContextLoader

public static final String GLOBAL_INITIALIZER_CLASSES_PARAM

org.springframework.web.context.ContextLoader

protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc)

{
    if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
        String idParam = sc.getInitParameter(CONTEXT_ID_PARAM);
        if (idParam != null) {
            wac.setId(idParam);
        } else {
            wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX + ObjectUtils.getDisplayString(sc.getContextPath()));
        }
    } 
    wac.setServletContext(sc);
    String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM);
    if (configLocationParam != null) {
        wac.setConfigLocation(configLocationParam);
    } 
    ConfigurableEnvironment env = wac.getEnvironment();
    if (env instanceof ConfigurableWebEnvironment) {
        ((ConfigurableWebEnvironment)env).initPropertySources(sc, null);
    } 
    customizeContext(sc, wac);
    wac.refresh();
}
org.springframework.web.context.ContextLoader

protected WebApplicationContext createWebApplicationContext(ServletContext sc)

{
    Class<?> contextClass = determineContextClass(sc);
    if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
        throw new ApplicationContextException("Custom context class [" + contextClass.getName() + "] is not of type [" + ConfigurableWebApplicationContext.class.getName() + "]");
    } 
    return (ConfigurableWebApplicationContext)BeanUtils.instantiateClass(contextClass);
}
org.springframework.web.context.ContextLoader

@Nullable volatile static WebApplicationContext currentContext

org.springframework.web.context.ContextLoader

@Nullable public static WebApplicationContext getCurrentWebApplicationContext()

{
    ClassLoader ccl = Thread.currentThread().getContextClassLoader();
    if (ccl != null) {
        WebApplicationContext ccpt = currentContextPerThread.get(ccl);
        if (ccpt != null) {
            return ccpt;
        } 
    } 
    return currentContext;
}
org.springframework.web.context.ContextLoader

public WebApplicationContext initWebApplicationContext(ServletContext servletContext)

{
    if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {
        throw new IllegalStateException("Cannot initialize context because there is already a root application context present - " + "check whether you have multiple ContextLoader* definitions in your web.xml!");
    } 
    servletContext.log("Initializing Spring root WebApplicationContext");
    Log logger = LogFactory.getLog(ContextLoader.class);
    if (logger.isInfoEnabled()) {
        logger.info("Root WebApplicationContext: initialization started");
    } 
    long startTime = System.currentTimeMillis();
    try {
        if (this.context == null) {
            this.context = createWebApplicationContext(servletContext);
        } 
        if (this.context instanceof ConfigurableWebApplicationContext) {
            ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext)this.context;
            if (!cwac.isActive()) {
                if (cwac.getParent() == null) {
                    ApplicationContext parent = loadParentContext(servletContext);
                    cwac.setParent(parent);
                } 
                configureAndRefreshWebApplicationContext(cwac, servletContext);
            } 
        } 
        servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
        ClassLoader ccl = Thread.currentThread().getContextClassLoader();
        if (ccl == ContextLoader.class.getClassLoader()) {
            currentContext = this.context;
        } else if (ccl != null) {
            currentContextPerThread.put(ccl, this.context);
        } 
        if (logger.isInfoEnabled()) {
            long elapsedTime = System.currentTimeMillis() - startTime;
            logger.info("Root WebApplicationContext initialized in " + elapsedTime + " ms");
        } 
        return this.context;
    } catch (RuntimeException | Error ex) {
        logger.error("Context initialization failed", ex);
        servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
        throw ex;
    }
}
org.springframework.web.context.ContextLoader

@Nullable protected ApplicationContext loadParentContext(ServletContext servletContext)

{
    return null;
}
org.springframework.web.context.ContextLoader

@SuppressWarnings("unchecked") public void setContextInitializers(@Nullable ApplicationContextInitializer<?>... initializers)

{
    if (initializers != null) {
        for (ApplicationContextInitializer<?> initializer: initializers) {
            this.contextInitializers.add((ApplicationContextInitializer<ConfigurableApplicationContext>)initializer);
        }
    } 
}

ContextLoaderListener
extends ContextLoader implements ServletContextListener

org.springframework.web.context.ContextLoaderListener

public ContextLoaderListener ContextLoaderListener()

{
}
org.springframework.web.context.ContextLoaderListener

public ContextLoaderListener ContextLoaderListener(WebApplicationContext context)

{
    super(context);
}
org.springframework.web.context.ContextLoaderListener

@Override public void contextDestroyed(ServletContextEvent event)

{
    closeWebApplicationContext(event.getServletContext());
    ContextCleanupListener.cleanupAttributes(event.getServletContext());
}
org.springframework.web.context.ContextLoaderListener

@Override public void contextInitialized(ServletContextEvent event)

{
    initWebApplicationContext(event.getServletContext());
}

ServletConfigAware
inherit classes
  • Aware

ServletContextAware
inherit classes
  • Aware

WebApplicationContext
inherit classes
  • ApplicationContext

@ApplicationScope
org.springframework.web.context.annotation.ApplicationScope

@AliasFor(annotation=Scope.class) private ScopedProxyMode proxyMode()


@RequestScope
org.springframework.web.context.annotation.RequestScope

@AliasFor(annotation=Scope.class) private ScopedProxyMode proxyMode()


@SessionScope
org.springframework.web.context.annotation.SessionScope

@AliasFor(annotation=Scope.class) private ScopedProxyMode proxyMode()




AbstractRequestAttributes
implements RequestAttributes

org.springframework.web.context.request.AbstractRequestAttributes

protected final boolean isRequestActive()

{
    return this.requestActive;
}
org.springframework.web.context.request.AbstractRequestAttributes

protected final void registerRequestDestructionCallback(String name, Runnable callback)

{
    Assert.notNull(name, "Name must not be null");
    Assert.notNull(callback, "Callback must not be null");
    synchronized(this.requestDestructionCallbacks) {
        this.requestDestructionCallbacks.put(name, callback);
    }
}
org.springframework.web.context.request.AbstractRequestAttributes

protected final void removeRequestDestructionCallback(String name)

{
    Assert.notNull(name, "Name must not be null");
    synchronized(this.requestDestructionCallbacks) {
        this.requestDestructionCallbacks.remove(name);
    }
}
org.springframework.web.context.request.AbstractRequestAttributes

volatile boolean requestActive

org.springframework.web.context.request.AbstractRequestAttributes

public void requestCompleted()

{
    executeRequestDestructionCallbacks();
    updateAccessedSessionAttributes();
    this.requestActive = false;
}
org.springframework.web.context.request.AbstractRequestAttributes

protected final Map<String, Runnable> requestDestructionCallbacks

org.springframework.web.context.request.AbstractRequestAttributes

protected abstract void updateAccessedSessionAttributes()


AbstractRequestAttributesScope
implements Scope

org.springframework.web.context.request.AbstractRequestAttributesScope

protected abstract int getScope()

org.springframework.web.context.request.AbstractRequestAttributesScope

@Override public void registerDestructionCallback(String name, Runnable callback)

{
    RequestAttributes attributes = RequestContextHolder.currentRequestAttributes();
    attributes.registerDestructionCallback(name, callback, getScope());
}
org.springframework.web.context.request.AbstractRequestAttributesScope

@Override @Nullable public Object resolveContextualObject(String key)

{
    RequestAttributes attributes = RequestContextHolder.currentRequestAttributes();
    return attributes.resolveReference(key);
}

AsyncWebRequestInterceptor
inherit classes
  • WebRequestInterceptor

DestructionCallbackBindingListener
implements HttpSessionBindingListener, Serializable

org.springframework.web.context.request.DestructionCallbackBindingListener

public DestructionCallbackBindingListener DestructionCallbackBindingListener(Runnable destructionCallback)

{
    this.destructionCallback = destructionCallback;
}
org.springframework.web.context.request.DestructionCallbackBindingListener

@Override public void valueBound(HttpSessionBindingEvent event)

{
}
org.springframework.web.context.request.DestructionCallbackBindingListener

@Override public void valueUnbound(HttpSessionBindingEvent event)

{
    this.destructionCallback.run();
}

FacesRequestAttributes
implements RequestAttributes

org.springframework.web.context.request.FacesRequestAttributes

public FacesRequestAttributes FacesRequestAttributes(FacesContext facesContext)

{
    Assert.notNull(facesContext, "FacesContext must not be null");
    this.facesContext = facesContext;
}
org.springframework.web.context.request.FacesRequestAttributes

@Override public Object getAttribute(String name, int scope)

{
    return getAttributeMap(scope).get(name);
}
org.springframework.web.context.request.FacesRequestAttributes

protected Map<String, Object> getAttributeMap(int scope)

{
    if (scope == SCOPE_REQUEST) {
        return getExternalContext().getRequestMap();
    } else {
        return getExternalContext().getSessionMap();
    }
}
org.springframework.web.context.request.FacesRequestAttributes

@Override public String[] getAttributeNames(int scope)

{
    return StringUtils.toStringArray(getAttributeMap(scope).keySet());
}
org.springframework.web.context.request.FacesRequestAttributes

protected final ExternalContext getExternalContext()

{
    return getFacesContext().getExternalContext();
}
org.springframework.web.context.request.FacesRequestAttributes

protected final FacesContext getFacesContext()

{
    return this.facesContext;
}
org.springframework.web.context.request.FacesRequestAttributes

@Override public void registerDestructionCallback(String name, Runnable callback, int scope)

{
    if (logger.isWarnEnabled()) {
        logger.warn("Could not register destruction callback [" + callback + "] for attribute '" + name + "' because FacesRequestAttributes does not support such callbacks");
    } 
}
org.springframework.web.context.request.FacesRequestAttributes

@Override public void removeAttribute(String name, int scope)

{
    getAttributeMap(scope).remove(name);
}
org.springframework.web.context.request.FacesRequestAttributes

@Override public Object resolveReference(String key)

{
    if (REFERENCE_REQUEST.equals(key)) {
        return getExternalContext().getRequest();
    } else if (REFERENCE_SESSION.equals(key)) {
        return getExternalContext().getSession(true);
    } else if ("application".equals(key)) {
        return getExternalContext().getContext();
    } else if ("requestScope".equals(key)) {
        return getExternalContext().getRequestMap();
    } else if ("sessionScope".equals(key)) {
        return getExternalContext().getSessionMap();
    } else if ("applicationScope".equals(key)) {
        return getExternalContext().getApplicationMap();
    } else if ("facesContext".equals(key)) {
        return getFacesContext();
    } else if ("cookie".equals(key)) {
        return getExternalContext().getRequestCookieMap();
    } else if ("header".equals(key)) {
        return getExternalContext().getRequestHeaderMap();
    } else if ("headerValues".equals(key)) {
        return getExternalContext().getRequestHeaderValuesMap();
    } else if ("param".equals(key)) {
        return getExternalContext().getRequestParameterMap();
    } else if ("paramValues".equals(key)) {
        return getExternalContext().getRequestParameterValuesMap();
    } else if ("initParam".equals(key)) {
        return getExternalContext().getInitParameterMap();
    } else if ("view".equals(key)) {
        return getFacesContext().getViewRoot();
    } else if ("viewScope".equals(key)) {
        return getFacesContext().getViewRoot().getViewMap();
    } else if ("flash".equals(key)) {
        return getExternalContext().getFlash();
    } else if ("resource".equals(key)) {
        return getFacesContext().getApplication().getResourceHandler();
    } else {
        return null;
    }
}
org.springframework.web.context.request.FacesRequestAttributes

@Override public void setAttribute(String name, Object value, int scope)

{
    getAttributeMap(scope).put(name, value);
}

FacesWebRequest
extends FacesRequestAttributes implements NativeWebRequest

org.springframework.web.context.request.FacesWebRequest

public FacesWebRequest FacesWebRequest(FacesContext facesContext)

{
    super(facesContext);
}
org.springframework.web.context.request.FacesWebRequest

@Override public boolean checkNotModified(long lastModifiedTimestamp)

{
    return false;
}
org.springframework.web.context.request.FacesWebRequest

@Override public boolean checkNotModified(@Nullable String eTag)

{
    return false;
}
org.springframework.web.context.request.FacesWebRequest

@Override public boolean checkNotModified(@Nullable String etag, long lastModifiedTimestamp)

{
    return false;
}
org.springframework.web.context.request.FacesWebRequest

@Override public String getContextPath()

{
    return getFacesContext().getExternalContext().getRequestContextPath();
}
org.springframework.web.context.request.FacesWebRequest

@Override @Nullable public String getHeader(String headerName)

{
    return getExternalContext().getRequestHeaderMap().get(headerName);
}
org.springframework.web.context.request.FacesWebRequest

@Override public Iterator<String> getHeaderNames()

{
    return getExternalContext().getRequestHeaderMap().keySet().iterator();
}
org.springframework.web.context.request.FacesWebRequest

@Override @Nullable public String[] getHeaderValues(String headerName)

{
    return getExternalContext().getRequestHeaderValuesMap().get(headerName);
}
org.springframework.web.context.request.FacesWebRequest

@Override public Locale getLocale()

{
    return getFacesContext().getExternalContext().getRequestLocale();
}
org.springframework.web.context.request.FacesWebRequest

@Override public Object getNativeRequest()

{
    return getExternalContext().getRequest();
}
org.springframework.web.context.request.FacesWebRequest

<T>@Override @SuppressWarnings("unchecked") public T getNativeRequest(@Nullable Class<T> requiredType)

{
    if (requiredType != null) {
        Object request = getExternalContext().getRequest();
        if (requiredType.isInstance(request)) {
            return (T)request;
        } 
    } 
    return null;
}
org.springframework.web.context.request.FacesWebRequest

@Override public Object getNativeResponse()

{
    return getExternalContext().getResponse();
}
org.springframework.web.context.request.FacesWebRequest

<T>@Override @SuppressWarnings("unchecked") public T getNativeResponse(@Nullable Class<T> requiredType)

{
    if (requiredType != null) {
        Object response = getExternalContext().getResponse();
        if (requiredType.isInstance(response)) {
            return (T)response;
        } 
    } 
    return null;
}
org.springframework.web.context.request.FacesWebRequest

@Override @Nullable public String getParameter(String paramName)

{
    return getExternalContext().getRequestParameterMap().get(paramName);
}
org.springframework.web.context.request.FacesWebRequest

@Override public Map<String, String[]> getParameterMap()

{
    return getExternalContext().getRequestParameterValuesMap();
}
org.springframework.web.context.request.FacesWebRequest

@Override public Iterator<String> getParameterNames()

{
    return getExternalContext().getRequestParameterNames();
}
org.springframework.web.context.request.FacesWebRequest

@Override @Nullable public String[] getParameterValues(String paramName)

{
    return getExternalContext().getRequestParameterValuesMap().get(paramName);
}
org.springframework.web.context.request.FacesWebRequest

@Override @Nullable public String getRemoteUser()

{
    return getFacesContext().getExternalContext().getRemoteUser();
}
org.springframework.web.context.request.FacesWebRequest

@Override @Nullable public Principal getUserPrincipal()

{
    return getFacesContext().getExternalContext().getUserPrincipal();
}
org.springframework.web.context.request.FacesWebRequest

@Override public boolean isSecure()

{
    return false;
}
org.springframework.web.context.request.FacesWebRequest

@Override public boolean isUserInRole(String role)

{
    return getFacesContext().getExternalContext().isUserInRole(role);
}
org.springframework.web.context.request.FacesWebRequest

@Override public String toString()

{
    return "FacesWebRequest: " + getDescription(true);
}

NativeWebRequest
inherit classes
  • WebRequest

RequestAttributes

RequestContextHolder

org.springframework.web.context.request.RequestContextHolder

@Nullable public static RequestAttributes getRequestAttributes()

{
    RequestAttributes attributes = requestAttributesHolder.get();
    if (attributes == null) {
        attributes = inheritableRequestAttributesHolder.get();
    } 
    return attributes;
}
org.springframework.web.context.request.RequestContextHolder

public static void resetRequestAttributes()

{
    requestAttributesHolder.remove();
    inheritableRequestAttributesHolder.remove();
}
org.springframework.web.context.request.RequestContextHolder

public static void setRequestAttributes(@Nullable RequestAttributes attributes)

{
    setRequestAttributes(attributes, false);
}
org.springframework.web.context.request.RequestContextHolder

public static void setRequestAttributes(@Nullable RequestAttributes attributes, boolean inheritable)

{
    if (attributes == null) {
        resetRequestAttributes();
    } else {
        if (inheritable) {
            inheritableRequestAttributesHolder.set(attributes);
            requestAttributesHolder.remove();
        } else {
            requestAttributesHolder.set(attributes);
            inheritableRequestAttributesHolder.remove();
        }
    }
}

RequestContextListener
implements ServletRequestListener

org.springframework.web.context.request.RequestContextListener

@Override public void requestInitialized(ServletRequestEvent requestEvent)

{
    if (!(requestEvent.getServletRequest() instanceof HttpServletRequest)) {
        throw new IllegalArgumentException("Request is not an HttpServletRequest: " + requestEvent.getServletRequest());
    } 
    HttpServletRequest request = (HttpServletRequest)requestEvent.getServletRequest();
    ServletRequestAttributes attributes = new ServletRequestAttributes(request);
    request.setAttribute(REQUEST_ATTRIBUTES_ATTRIBUTE, attributes);
    LocaleContextHolder.setLocale(request.getLocale());
    RequestContextHolder.setRequestAttributes(attributes);
}

RequestScope
extends AbstractRequestAttributesScope

org.springframework.web.context.request.RequestScope

@Override @Nullable public String getConversationId()

{
    return null;
}
org.springframework.web.context.request.RequestScope

@Override protected int getScope()

{
    return RequestAttributes.SCOPE_REQUEST;
}

ServletRequestAttributes
extends AbstractRequestAttributes

org.springframework.web.context.request.ServletRequestAttributes

public static final String DESTRUCTION_CALLBACK_NAME_PREFIX

org.springframework.web.context.request.ServletRequestAttributes

public ServletRequestAttributes ServletRequestAttributes(HttpServletRequest request)

{
    Assert.notNull(request, "Request must not be null");
    this.request = request;
}
org.springframework.web.context.request.ServletRequestAttributes

public ServletRequestAttributes ServletRequestAttributes(HttpServletRequest request, @Nullable HttpServletResponse response)

{
    this(request);
    this.response = response;
}
org.springframework.web.context.request.ServletRequestAttributes

@Override public Object getAttribute(String name, int scope)

{
    if (scope == SCOPE_REQUEST) {
        if (!isRequestActive()) {
            throw new IllegalStateException("Cannot ask for request attribute - request is not active anymore!");
        } 
        return this.request.getAttribute(name);
    } else {
        HttpSession session = getSession(false);
        if (session != null) {
            try {
                Object value = session.getAttribute(name);
                if (value != null) {
                    this.sessionAttributesToUpdate.put(name, value);
                } 
                return value;
            } catch (IllegalStateException ex) {
            }
        } 
        return null;
    }
}
org.springframework.web.context.request.ServletRequestAttributes

@Override public String[] getAttributeNames(int scope)

{
    if (scope == SCOPE_REQUEST) {
        if (!isRequestActive()) {
            throw new IllegalStateException("Cannot ask for request attributes - request is not active anymore!");
        } 
        return StringUtils.toStringArray(this.request.getAttributeNames());
    } else {
        HttpSession session = getSession(false);
        if (session != null) {
            try {
                return StringUtils.toStringArray(session.getAttributeNames());
            } catch (IllegalStateException ex) {
            }
        } 
        return new String[0];
    }
}
org.springframework.web.context.request.ServletRequestAttributes

public final HttpServletRequest getRequest()

{
    return this.request;
}
org.springframework.web.context.request.ServletRequestAttributes

@Nullable public final HttpServletResponse getResponse()

{
    return this.response;
}
org.springframework.web.context.request.ServletRequestAttributes

@Override public String getSessionId()

{
    return obtainSession().getId();
}
org.springframework.web.context.request.ServletRequestAttributes

@Override public Object getSessionMutex()

{
    return WebUtils.getSessionMutex(obtainSession());
}
org.springframework.web.context.request.ServletRequestAttributes

protected static final Set<Class<?>> immutableValueTypes

org.springframework.web.context.request.ServletRequestAttributes

protected boolean isImmutableSessionAttribute(String name, @Nullable Object value)

{
    return (value == null || immutableValueTypes.contains(value.getClass()));
}
org.springframework.web.context.request.ServletRequestAttributes

@Override public void registerDestructionCallback(String name, Runnable callback, int scope)

{
    if (scope == SCOPE_REQUEST) {
        registerRequestDestructionCallback(name, callback);
    } else {
        registerSessionDestructionCallback(name, callback);
    }
}
org.springframework.web.context.request.ServletRequestAttributes

protected void registerSessionDestructionCallback(String name, Runnable callback)

{
    HttpSession session = obtainSession();
    session.setAttribute(DESTRUCTION_CALLBACK_NAME_PREFIX + name, new DestructionCallbackBindingListener(callback));
}
org.springframework.web.context.request.ServletRequestAttributes

@Override public Object resolveReference(String key)

{
    if (REFERENCE_REQUEST.equals(key)) {
        return this.request;
    } else if (REFERENCE_SESSION.equals(key)) {
        return getSession(true);
    } else {
        return null;
    }
}
org.springframework.web.context.request.ServletRequestAttributes

@Nullable volatile HttpSession session

org.springframework.web.context.request.ServletRequestAttributes

@Override public void setAttribute(String name, Object value, int scope)

{
    if (scope == SCOPE_REQUEST) {
        if (!isRequestActive()) {
            throw new IllegalStateException("Cannot set request attribute - request is not active anymore!");
        } 
        this.request.setAttribute(name, value);
    } else {
        HttpSession session = obtainSession();
        this.sessionAttributesToUpdate.remove(name);
        session.setAttribute(name, value);
    }
}
org.springframework.web.context.request.ServletRequestAttributes

@Override public String toString()

{
    return this.request.toString();
}

ServletWebRequest
extends ServletRequestAttributes implements NativeWebRequest

org.springframework.web.context.request.ServletWebRequest

public ServletWebRequest ServletWebRequest(HttpServletRequest request)

{
    super(request);
}
org.springframework.web.context.request.ServletWebRequest

public ServletWebRequest ServletWebRequest(HttpServletRequest request, @Nullable HttpServletResponse response)

{
    super(request, response);
}
org.springframework.web.context.request.ServletWebRequest

@Override public boolean checkNotModified(long lastModifiedTimestamp)

{
    return checkNotModified(null, lastModifiedTimestamp);
}
org.springframework.web.context.request.ServletWebRequest

@Override public boolean checkNotModified(String etag)

{
    return checkNotModified(etag, -1);
}
org.springframework.web.context.request.ServletWebRequest

@Override public String getContextPath()

{
    return getRequest().getContextPath();
}
org.springframework.web.context.request.ServletWebRequest

@Override public String getDescription(boolean includeClientInfo)

{
    HttpServletRequest request = getRequest();
    StringBuilder sb = new StringBuilder();
    sb.append("uri=").append(request.getRequestURI());
    if (includeClientInfo) {
        String client = request.getRemoteAddr();
        if (StringUtils.hasLength(client)) {
            sb.append(";client=").append(client);
        } 
        HttpSession session = request.getSession(false);
        if (session != null) {
            sb.append(";session=").append(session.getId());
        } 
        String user = request.getRemoteUser();
        if (StringUtils.hasLength(user)) {
            sb.append(";user=").append(user);
        } 
    } 
    return sb.toString();
}
org.springframework.web.context.request.ServletWebRequest

@Override @Nullable public String getHeader(String headerName)

{
    return getRequest().getHeader(headerName);
}
org.springframework.web.context.request.ServletWebRequest

@Override public Iterator<String> getHeaderNames()

{
    return CollectionUtils.toIterator(getRequest().getHeaderNames());
}
org.springframework.web.context.request.ServletWebRequest

@Override @Nullable public String[] getHeaderValues(String headerName)

{
    String[] headerValues = StringUtils.toStringArray(getRequest().getHeaders(headerName));
    return (!ObjectUtils.isEmpty(headerValues) ? headerValues : null);
}
org.springframework.web.context.request.ServletWebRequest

@Nullable public HttpMethod getHttpMethod()

{
    return HttpMethod.resolve(getRequest().getMethod());
}
org.springframework.web.context.request.ServletWebRequest

@Override public Locale getLocale()

{
    return getRequest().getLocale();
}
org.springframework.web.context.request.ServletWebRequest

@Override public Object getNativeRequest()

{
    return getRequest();
}
org.springframework.web.context.request.ServletWebRequest

<T>@Override public T getNativeRequest(@Nullable Class<T> requiredType)

{
    return WebUtils.getNativeRequest(getRequest(), requiredType);
}
org.springframework.web.context.request.ServletWebRequest

@Override public Object getNativeResponse()

{
    return getResponse();
}
org.springframework.web.context.request.ServletWebRequest

<T>@Override public T getNativeResponse(@Nullable Class<T> requiredType)

{
    HttpServletResponse response = getResponse();
    return (response != null ? WebUtils.getNativeResponse(response, requiredType) : null);
}
org.springframework.web.context.request.ServletWebRequest

@Override @Nullable public String getParameter(String paramName)

{
    return getRequest().getParameter(paramName);
}
org.springframework.web.context.request.ServletWebRequest

@Override public Map<String, String[]> getParameterMap()

{
    return getRequest().getParameterMap();
}
org.springframework.web.context.request.ServletWebRequest

@Override public Iterator<String> getParameterNames()

{
    return CollectionUtils.toIterator(getRequest().getParameterNames());
}
org.springframework.web.context.request.ServletWebRequest

@Override @Nullable public String[] getParameterValues(String paramName)

{
    return getRequest().getParameterValues(paramName);
}
org.springframework.web.context.request.ServletWebRequest

@Override @Nullable public String getRemoteUser()

{
    return getRequest().getRemoteUser();
}
org.springframework.web.context.request.ServletWebRequest

@Override @Nullable public Principal getUserPrincipal()

{
    return getRequest().getUserPrincipal();
}
org.springframework.web.context.request.ServletWebRequest

public boolean isNotModified()

{
    return this.notModified;
}
org.springframework.web.context.request.ServletWebRequest

@Override public boolean isSecure()

{
    return getRequest().isSecure();
}
org.springframework.web.context.request.ServletWebRequest

@Override public boolean isUserInRole(String role)

{
    return getRequest().isUserInRole(role);
}
org.springframework.web.context.request.ServletWebRequest

@Override public String toString()

{
    return "ServletWebRequest: " + getDescription(true);
}

SessionScope
extends AbstractRequestAttributesScope

org.springframework.web.context.request.SessionScope

@Override public Object get(String name, ObjectFactory<?> objectFactory)

{
    Object mutex = RequestContextHolder.currentRequestAttributes().getSessionMutex();
    synchronized(mutex) {
        return super.get(name, objectFactory);
    }
}
org.springframework.web.context.request.SessionScope

@Override public String getConversationId()

{
    return RequestContextHolder.currentRequestAttributes().getSessionId();
}
org.springframework.web.context.request.SessionScope

@Override protected int getScope()

{
    return RequestAttributes.SCOPE_SESSION;
}
org.springframework.web.context.request.SessionScope

@Override @Nullable public Object remove(String name)

{
    Object mutex = RequestContextHolder.currentRequestAttributes().getSessionMutex();
    synchronized(mutex) {
        return super.remove(name);
    }
}

WebRequest
inherit classes
  • RequestAttributes

WebRequestInterceptor

AsyncRequestTimeoutException
extends RuntimeException


AsyncWebRequest
inherit classes
  • NativeWebRequest

CallableInterceptorChain

org.springframework.web.context.request.async.CallableInterceptorChain

public CallableInterceptorChain CallableInterceptorChain(List<CallableProcessingInterceptor> interceptors)

{
    this.interceptors = interceptors;
}
org.springframework.web.context.request.async.CallableInterceptorChain

public void applyBeforeConcurrentHandling(NativeWebRequest request, Callable<?> task)

{
    for (CallableProcessingInterceptor interceptor: this.interceptors) {
        interceptor.beforeConcurrentHandling(request, task);
    }
}
org.springframework.web.context.request.async.CallableInterceptorChain

public Object applyPostProcess(NativeWebRequest request, Callable<?> task, Object concurrentResult)

{
    Throwable exceptionResult = null;
    for (int i = this.preProcessIndex; i >= 0; i--) {
        try {
            this.interceptors.get(i).postProcess(request, task, concurrentResult);
        } catch (Throwable ex) {
            if (exceptionResult != null) {
                if (logger.isTraceEnabled()) {
                    logger.trace("Ignoring failure in postProcess method", ex);
                } 
            } else {
                exceptionResult = ex;
            }
        }
    }
    return (exceptionResult != null) ? exceptionResult : concurrentResult;
}
org.springframework.web.context.request.async.CallableInterceptorChain

public void applyPreProcess(NativeWebRequest request, Callable<?> task)

{
    for (CallableProcessingInterceptor interceptor: this.interceptors) {
        interceptor.preProcess(request, task);
        this.preProcessIndex++;
    }
}
org.springframework.web.context.request.async.CallableInterceptorChain

public void setTaskFuture(Future<?> taskFuture)

{
    this.taskFuture = taskFuture;
}
org.springframework.web.context.request.async.CallableInterceptorChain

volatile Future<?> taskFuture

org.springframework.web.context.request.async.CallableInterceptorChain

public void triggerAfterCompletion(NativeWebRequest request, Callable<?> task)

{
    for (int i = this.interceptors.size() - 1; i >= 0; i--) {
        try {
            this.interceptors.get(i).afterCompletion(request, task);
        } catch (Throwable ex) {
            if (logger.isTraceEnabled()) {
                logger.trace("Ignoring failure in afterCompletion method", ex);
            } 
        }
    }
}
org.springframework.web.context.request.async.CallableInterceptorChain

public Object triggerAfterError(NativeWebRequest request, Callable<?> task, Throwable throwable)

{
    cancelTask();
    for (CallableProcessingInterceptor interceptor: this.interceptors) {
        try {
            Object result = interceptor.handleError(request, task, throwable);
            if (result == CallableProcessingInterceptor.RESPONSE_HANDLED) {
                break;
            } else if (result != CallableProcessingInterceptor.RESULT_NONE) {
                return result;
            } 
        } catch (Throwable ex) {
            return ex;
        }
    }
    return CallableProcessingInterceptor.RESULT_NONE;
}
org.springframework.web.context.request.async.CallableInterceptorChain

public Object triggerAfterTimeout(NativeWebRequest request, Callable<?> task)

{
    cancelTask();
    for (CallableProcessingInterceptor interceptor: this.interceptors) {
        try {
            Object result = interceptor.handleTimeout(request, task);
            if (result == CallableProcessingInterceptor.RESPONSE_HANDLED) {
                break;
            } else if (result != CallableProcessingInterceptor.RESULT_NONE) {
                return result;
            } 
        } catch (Throwable ex) {
            return ex;
        }
    }
    return CallableProcessingInterceptor.RESULT_NONE;
}

CallableProcessingInterceptor

CallableProcessingInterceptorAdapter
implements CallableProcessingInterceptor

org.springframework.web.context.request.async.CallableProcessingInterceptorAdapter

<T>@Override public void afterCompletion(NativeWebRequest request, Callable<T> task)

{
}
org.springframework.web.context.request.async.CallableProcessingInterceptorAdapter

<T>@Override public void beforeConcurrentHandling(NativeWebRequest request, Callable<T> task)

{
}
org.springframework.web.context.request.async.CallableProcessingInterceptorAdapter

<T>@Override public Object handleError(NativeWebRequest request, Callable<T> task, Throwable t)

{
    return RESULT_NONE;
}
org.springframework.web.context.request.async.CallableProcessingInterceptorAdapter

<T>@Override public Object handleTimeout(NativeWebRequest request, Callable<T> task)

{
    return RESULT_NONE;
}
org.springframework.web.context.request.async.CallableProcessingInterceptorAdapter

<T>@Override public void postProcess(NativeWebRequest request, Callable<T> task, Object concurrentResult)

{
}
org.springframework.web.context.request.async.CallableProcessingInterceptorAdapter

<T>@Override public void preProcess(NativeWebRequest request, Callable<T> task)

{
}

DeferredResult<T>

org.springframework.web.context.request.async.DeferredResult

public DeferredResult DeferredResult()

{
    this(null, () -> RESULT_NONE);
}
org.springframework.web.context.request.async.DeferredResult

public DeferredResult DeferredResult(Long timeoutValue)

{
    this(timeoutValue, () -> RESULT_NONE);
}
org.springframework.web.context.request.async.DeferredResult

public DeferredResult DeferredResult(@Nullable Long timeoutValue, Object timeoutResult)

{
    this.timeoutValue = timeoutValue;
    this.timeoutResult = () -> timeoutResult;
}
org.springframework.web.context.request.async.DeferredResult

public DeferredResult DeferredResult(@Nullable Long timeoutValue, Supplier<?> timeoutResult)

{
    this.timeoutValue = timeoutValue;
    this.timeoutResult = timeoutResult;
}
DeferredResultHandler
org.springframework.web.context.request.async.DeferredResult

volatile boolean expired

org.springframework.web.context.request.async.DeferredResult

@Nullable public Object getResult()

{
    Object resultToCheck = this.result;
    return (resultToCheck != RESULT_NONE ? resultToCheck : null);
}
org.springframework.web.context.request.async.DeferredResult

public boolean hasResult()

{
    return (this.result != RESULT_NONE);
}
org.springframework.web.context.request.async.DeferredResult

public final boolean isSetOrExpired()

{
    return (this.result != RESULT_NONE || this.expired);
}
org.springframework.web.context.request.async.DeferredResult

public void onCompletion(Runnable callback)

{
    this.completionCallback = callback;
}
org.springframework.web.context.request.async.DeferredResult

public void onError(Consumer<Throwable> callback)

{
    this.errorCallback = callback;
}
org.springframework.web.context.request.async.DeferredResult

public void onTimeout(Runnable callback)

{
    this.timeoutCallback = callback;
}
org.springframework.web.context.request.async.DeferredResult

volatile Object result

org.springframework.web.context.request.async.DeferredResult

public boolean setErrorResult(Object result)

{
    return setResultInternal(result);
}
org.springframework.web.context.request.async.DeferredResult

public boolean setResult(T result)

{
    return setResultInternal(result);
}
org.springframework.web.context.request.async.DeferredResult

public final void setResultHandler(DeferredResultHandler resultHandler)

{
    Assert.notNull(resultHandler, "DeferredResultHandler is required");
    if (this.expired) {
        return ;
    } 
    Object resultToHandle;
    synchronized(this) {
        if (this.expired) {
            return ;
        } 
        resultToHandle = this.result;
        if (resultToHandle == RESULT_NONE) {
            this.resultHandler = resultHandler;
            return ;
        } 
    }
    try {
        resultHandler.handleResult(resultToHandle);
    } catch (Throwable ex) {
        logger.debug("Failed to process async result", ex);
    }
}

DeferredResultInterceptorChain

org.springframework.web.context.request.async.DeferredResultInterceptorChain

public DeferredResultInterceptorChain DeferredResultInterceptorChain(List<DeferredResultProcessingInterceptor> interceptors)

{
    this.interceptors = interceptors;
}
org.springframework.web.context.request.async.DeferredResultInterceptorChain

public void applyBeforeConcurrentHandling(NativeWebRequest request, DeferredResult<?> deferredResult)

{
    for (DeferredResultProcessingInterceptor interceptor: this.interceptors) {
        interceptor.beforeConcurrentHandling(request, deferredResult);
    }
}
org.springframework.web.context.request.async.DeferredResultInterceptorChain

public Object applyPostProcess(NativeWebRequest request, DeferredResult<?> deferredResult, Object concurrentResult)

{
    try {
        for (int i = this.preProcessingIndex; i >= 0; i--) {
            this.interceptors.get(i).postProcess(request, deferredResult, concurrentResult);
        }
    } catch (Throwable ex) {
        return ex;
    }
    return concurrentResult;
}
org.springframework.web.context.request.async.DeferredResultInterceptorChain

public void applyPreProcess(NativeWebRequest request, DeferredResult<?> deferredResult)

{
    for (DeferredResultProcessingInterceptor interceptor: this.interceptors) {
        interceptor.preProcess(request, deferredResult);
        this.preProcessingIndex++;
    }
}
org.springframework.web.context.request.async.DeferredResultInterceptorChain

public void triggerAfterCompletion(NativeWebRequest request, DeferredResult<?> deferredResult)

{
    for (int i = this.preProcessingIndex; i >= 0; i--) {
        try {
            this.interceptors.get(i).afterCompletion(request, deferredResult);
        } catch (Throwable ex) {
            logger.trace("Ignoring failure in afterCompletion method", ex);
        }
    }
}
org.springframework.web.context.request.async.DeferredResultInterceptorChain

public boolean triggerAfterError(NativeWebRequest request, DeferredResult<?> deferredResult, Throwable ex)

{
    for (DeferredResultProcessingInterceptor interceptor: this.interceptors) {
        if (deferredResult.isSetOrExpired()) {
            return false;
        } 
        if (!interceptor.handleError(request, deferredResult, ex)) {
            return false;
        } 
    }
    return true;
}
org.springframework.web.context.request.async.DeferredResultInterceptorChain

public void triggerAfterTimeout(NativeWebRequest request, DeferredResult<?> deferredResult)

{
    for (DeferredResultProcessingInterceptor interceptor: this.interceptors) {
        if (deferredResult.isSetOrExpired()) {
            return ;
        } 
        if (!interceptor.handleTimeout(request, deferredResult)) {
            break;
        } 
    }
}

DeferredResultProcessingInterceptor

DeferredResultProcessingInterceptorAdapter
implements DeferredResultProcessingInterceptor

org.springframework.web.context.request.async.DeferredResultProcessingInterceptorAdapter

<T>@Override public void afterCompletion(NativeWebRequest request, DeferredResult<T> deferredResult)

{
}
org.springframework.web.context.request.async.DeferredResultProcessingInterceptorAdapter

<T>@Override public void beforeConcurrentHandling(NativeWebRequest request, DeferredResult<T> deferredResult)

{
}
org.springframework.web.context.request.async.DeferredResultProcessingInterceptorAdapter

<T>@Override public boolean handleError(NativeWebRequest request, DeferredResult<T> deferredResult, Throwable t)

{
    return true;
}
org.springframework.web.context.request.async.DeferredResultProcessingInterceptorAdapter

<T>@Override public boolean handleTimeout(NativeWebRequest request, DeferredResult<T> deferredResult)

{
    return true;
}
org.springframework.web.context.request.async.DeferredResultProcessingInterceptorAdapter

<T>@Override public void postProcess(NativeWebRequest request, DeferredResult<T> deferredResult, Object concurrentResult)

{
}
org.springframework.web.context.request.async.DeferredResultProcessingInterceptorAdapter

<T>@Override public void preProcess(NativeWebRequest request, DeferredResult<T> deferredResult)

{
}

StandardServletAsyncWebRequest
extends ServletWebRequest implements AsyncWebRequest, AsyncListener

org.springframework.web.context.request.async.StandardServletAsyncWebRequest

public StandardServletAsyncWebRequest StandardServletAsyncWebRequest(HttpServletRequest request, HttpServletResponse response)

{
    super(request, response);
}
org.springframework.web.context.request.async.StandardServletAsyncWebRequest

@Override public void addCompletionHandler(Runnable runnable)

{
    this.completionHandlers.add(runnable);
}
org.springframework.web.context.request.async.StandardServletAsyncWebRequest

@Override public void addErrorHandler(Consumer<Throwable> exceptionHandler)

{
    this.exceptionHandlers.add(exceptionHandler);
}
org.springframework.web.context.request.async.StandardServletAsyncWebRequest

@Override public void addTimeoutHandler(Runnable timeoutHandler)

{
    this.timeoutHandlers.add(timeoutHandler);
}
org.springframework.web.context.request.async.StandardServletAsyncWebRequest

@Override public void dispatch()

{
    Assert.notNull(this.asyncContext, "Cannot dispatch without an AsyncContext");
    this.asyncContext.dispatch();
}
org.springframework.web.context.request.async.StandardServletAsyncWebRequest

@Override public boolean isAsyncComplete()

{
    return this.asyncCompleted.get();
}
org.springframework.web.context.request.async.StandardServletAsyncWebRequest

@Override public boolean isAsyncStarted()

{
    return (this.asyncContext != null && getRequest().isAsyncStarted());
}
org.springframework.web.context.request.async.StandardServletAsyncWebRequest

@Override public void onComplete(AsyncEvent event)

{
    this.completionHandlers.forEach(Runnable::run);
    this.asyncContext = null;
    this.asyncCompleted.set(true);
}
org.springframework.web.context.request.async.StandardServletAsyncWebRequest

@Override public void onError(AsyncEvent event)

{
    this.exceptionHandlers.forEach(consumer -> consumer.accept(event.getThrowable()));
}
org.springframework.web.context.request.async.StandardServletAsyncWebRequest

@Override public void onStartAsync(AsyncEvent event)

{
}
org.springframework.web.context.request.async.StandardServletAsyncWebRequest

@Override public void onTimeout(AsyncEvent event)

{
    this.timeoutHandlers.forEach(Runnable::run);
}
org.springframework.web.context.request.async.StandardServletAsyncWebRequest

@Override public void setTimeout(Long timeout)

{
    Assert.state(!isAsyncStarted(), "Cannot change the timeout with concurrent handling in progress");
    this.timeout = timeout;
}

TimeoutCallableProcessingInterceptor
implements CallableProcessingInterceptor

org.springframework.web.context.request.async.TimeoutCallableProcessingInterceptor

<T>@Override public Object handleTimeout(NativeWebRequest request, Callable<T> task)

{
    return new AsyncRequestTimeoutException();
}

TimeoutDeferredResultProcessingInterceptor
implements DeferredResultProcessingInterceptor

org.springframework.web.context.request.async.TimeoutDeferredResultProcessingInterceptor

<T>@Override public boolean handleTimeout(NativeWebRequest request, DeferredResult<T> result)

{
    result.setErrorResult(new AsyncRequestTimeoutException());
    return false;
}

WebAsyncManager

org.springframework.web.context.request.async.WebAsyncManager

public void clearConcurrentResult()

{
    synchronized(WebAsyncManager.this) {
        this.concurrentResult = RESULT_NONE;
        this.concurrentResultContext = null;
    }
}
org.springframework.web.context.request.async.WebAsyncManager

volatile Object concurrentResult

org.springframework.web.context.request.async.WebAsyncManager

volatile Object[] concurrentResultContext

org.springframework.web.context.request.async.WebAsyncManager

@Nullable public CallableProcessingInterceptor getCallableInterceptor(Object key)

{
    return this.callableInterceptors.get(key);
}
org.springframework.web.context.request.async.WebAsyncManager

public Object getConcurrentResult()

{
    return this.concurrentResult;
}
org.springframework.web.context.request.async.WebAsyncManager

public Object[] getConcurrentResultContext()

{
    return this.concurrentResultContext;
}
org.springframework.web.context.request.async.WebAsyncManager

@Nullable public DeferredResultProcessingInterceptor getDeferredResultInterceptor(Object key)

{
    return this.deferredResultInterceptors.get(key);
}
org.springframework.web.context.request.async.WebAsyncManager

public boolean hasConcurrentResult()

{
    return (this.concurrentResult != RESULT_NONE);
}
org.springframework.web.context.request.async.WebAsyncManager

public boolean isConcurrentHandlingStarted()

{
    return (this.asyncWebRequest != null && this.asyncWebRequest.isAsyncStarted());
}
org.springframework.web.context.request.async.WebAsyncManager

public void registerCallableInterceptor(Object key, CallableProcessingInterceptor interceptor)

{
    Assert.notNull(key, "Key is required");
    Assert.notNull(interceptor, "CallableProcessingInterceptor  is required");
    this.callableInterceptors.put(key, interceptor);
}
org.springframework.web.context.request.async.WebAsyncManager

public void registerDeferredResultInterceptor(Object key, DeferredResultProcessingInterceptor interceptor)

{
    Assert.notNull(key, "Key is required");
    Assert.notNull(interceptor, "DeferredResultProcessingInterceptor is required");
    this.deferredResultInterceptors.put(key, interceptor);
}
org.springframework.web.context.request.async.WebAsyncManager

public void setTaskExecutor(AsyncTaskExecutor taskExecutor)

{
    this.taskExecutor = taskExecutor;
}
org.springframework.web.context.request.async.WebAsyncManager

@SuppressWarnings({"rawtypes","unchecked"}) public void startCallableProcessing(Callable<?> callable, Object... processingContext)

{
    Assert.notNull(callable, "Callable must not be null");
    startCallableProcessing(new WebAsyncTask(callable), processingContext);
}
org.springframework.web.context.request.async.WebAsyncManager

public void startCallableProcessing(final WebAsyncTask<?> webAsyncTask, Object... processingContext)

{
    Assert.notNull(webAsyncTask, "WebAsyncTask must not be null");
    Assert.state(this.asyncWebRequest != null, "AsyncWebRequest must not be null");
    Long timeout = webAsyncTask.getTimeout();
    if (timeout != null) {
        this.asyncWebRequest.setTimeout(timeout);
    } 
    AsyncTaskExecutor executor = webAsyncTask.getExecutor();
    if (executor != null) {
        this.taskExecutor = executor;
    } else {
        logExecutorWarning();
    }
    List<CallableProcessingInterceptor> interceptors = new ArrayList<>();
    interceptors.add(webAsyncTask.getInterceptor());
    interceptors.addAll(this.callableInterceptors.values());
    interceptors.add(timeoutCallableInterceptor);
    final Callable<?> callable = webAsyncTask.getCallable();
    final CallableInterceptorChain interceptorChain = new CallableInterceptorChain(interceptors);
    this.asyncWebRequest.addTimeoutHandler(() -> {
        if (logger.isDebugEnabled()) {
            logger.debug("Async request timeout for " + formatRequestUri());
        } 
        Object result = interceptorChain.triggerAfterTimeout(this.asyncWebRequest, callable);
        if (result != CallableProcessingInterceptor.RESULT_NONE) {
            setConcurrentResultAndDispatch(result);
        } 
    });
    this.asyncWebRequest.addErrorHandler(ex -> {
        if (logger.isDebugEnabled()) {
            logger.debug("Async request error for " + formatRequestUri() + ": " + ex);
        } 
        Object result = interceptorChain.triggerAfterError(this.asyncWebRequest, callable, ex);
        result = (result != CallableProcessingInterceptor.RESULT_NONE ? result : ex);
        setConcurrentResultAndDispatch(result);
    });
    this.asyncWebRequest.addCompletionHandler(() -> interceptorChain.triggerAfterCompletion(this.asyncWebRequest, callable));
    interceptorChain.applyBeforeConcurrentHandling(this.asyncWebRequest, callable);
    startAsyncProcessing(processingContext);
    try {
        Future<?> future = this.taskExecutor.submit(() -> {
            Object result = null;
            try {
                interceptorChain.applyPreProcess(this.asyncWebRequest, callable);
                result = callable.call();
            } catch (Throwable ex) {
                result = ex;
            } finally {
                result = interceptorChain.applyPostProcess(this.asyncWebRequest, callable, result);
            }
            setConcurrentResultAndDispatch(result);
        });
        interceptorChain.setTaskFuture(future);
    } catch (RejectedExecutionException ex) {
        Object result = interceptorChain.applyPostProcess(this.asyncWebRequest, callable, ex);
        setConcurrentResultAndDispatch(result);
        throw ex;
    }
}
org.springframework.web.context.request.async.WebAsyncManager

public void startDeferredResultProcessing(final DeferredResult<?> deferredResult, Object... processingContext)

{
    Assert.notNull(deferredResult, "DeferredResult must not be null");
    Assert.state(this.asyncWebRequest != null, "AsyncWebRequest must not be null");
    Long timeout = deferredResult.getTimeoutValue();
    if (timeout != null) {
        this.asyncWebRequest.setTimeout(timeout);
    } 
    List<DeferredResultProcessingInterceptor> interceptors = new ArrayList<>();
    interceptors.add(deferredResult.getInterceptor());
    interceptors.addAll(this.deferredResultInterceptors.values());
    interceptors.add(timeoutDeferredResultInterceptor);
    final DeferredResultInterceptorChain interceptorChain = new DeferredResultInterceptorChain(interceptors);
    this.asyncWebRequest.addTimeoutHandler(() -> {
        try {
            interceptorChain.triggerAfterTimeout(this.asyncWebRequest, deferredResult);
        } catch (Throwable ex) {
            setConcurrentResultAndDispatch(ex);
        }
    });
    this.asyncWebRequest.addErrorHandler(ex -> {
        try {
            if (!interceptorChain.triggerAfterError(this.asyncWebRequest, deferredResult, ex)) {
                return ;
            } 
            deferredResult.setErrorResult(ex);
        } catch (Throwable interceptorEx) {
            setConcurrentResultAndDispatch(interceptorEx);
        }
    });
    this.asyncWebRequest.addCompletionHandler(() -> interceptorChain.triggerAfterCompletion(this.asyncWebRequest, deferredResult));
    interceptorChain.applyBeforeConcurrentHandling(this.asyncWebRequest, deferredResult);
    startAsyncProcessing(processingContext);
    try {
        interceptorChain.applyPreProcess(this.asyncWebRequest, deferredResult);
        deferredResult.setResultHandler(result -> {
            result = interceptorChain.applyPostProcess(this.asyncWebRequest, deferredResult, result);
            setConcurrentResultAndDispatch(result);
        });
    } catch (Throwable ex) {
        setConcurrentResultAndDispatch(ex);
    }
}

WebAsyncTask<V>
implements BeanFactoryAware

org.springframework.web.context.request.async.WebAsyncTask

public WebAsyncTask WebAsyncTask(Callable<V> callable)

{
    Assert.notNull(callable, "Callable must not be null");
    this.callable = callable;
}
org.springframework.web.context.request.async.WebAsyncTask

public WebAsyncTask WebAsyncTask(long timeout, Callable<V> callable)

{
    this(callable);
    this.timeout = timeout;
}
org.springframework.web.context.request.async.WebAsyncTask

public WebAsyncTask WebAsyncTask(@Nullable Long timeout, String executorName, Callable<V> callable)

{
    this(callable);
    Assert.notNull(executorName, "Executor name must not be null");
    this.executorName = executorName;
    this.timeout = timeout;
}
org.springframework.web.context.request.async.WebAsyncTask

public WebAsyncTask WebAsyncTask(@Nullable Long timeout, AsyncTaskExecutor executor, Callable<V> callable)

{
    this(callable);
    Assert.notNull(executor, "Executor must not be null");
    this.executor = executor;
    this.timeout = timeout;
}
org.springframework.web.context.request.async.WebAsyncTask

public Callable<?> getCallable()

{
    return this.callable;
}
org.springframework.web.context.request.async.WebAsyncTask

@Nullable public Long getTimeout()

{
    return this.timeout;
}
org.springframework.web.context.request.async.WebAsyncTask

public void onCompletion(Runnable callback)

{
    this.completionCallback = callback;
}
org.springframework.web.context.request.async.WebAsyncTask

public void onError(Callable<V> callback)

{
    this.errorCallback = callback;
}
org.springframework.web.context.request.async.WebAsyncTask

public void onTimeout(Callable<V> callback)

{
    this.timeoutCallback = callback;
}
org.springframework.web.context.request.async.WebAsyncTask

@Override public void setBeanFactory(BeanFactory beanFactory)

{
    this.beanFactory = beanFactory;
}

WebAsyncUtils

org.springframework.web.context.request.async.WebAsyncUtils

public static final String WEB_ASYNC_MANAGER_ATTRIBUTE

org.springframework.web.context.request.async.WebAsyncUtils

public static AsyncWebRequest createAsyncWebRequest(HttpServletRequest request, HttpServletResponse response)

{
    return new StandardServletAsyncWebRequest(request, response);
}



AbstractRefreshableWebApplicationContext
extends AbstractRefreshableConfigApplicationContext implements ConfigurableWebApplicationContext, ThemeSource

org.springframework.web.context.support.AbstractRefreshableWebApplicationContext

public AbstractRefreshableWebApplicationContext AbstractRefreshableWebApplicationContext()

{
    setDisplayName("Root WebApplicationContext");
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext

@Override protected ConfigurableEnvironment createEnvironment()

{
    return new StandardServletEnvironment();
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext

@Override public String getApplicationName()

{
    return (this.servletContext != null ? this.servletContext.getContextPath() : "");
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext

@Override public String[] getConfigLocations()

{
    return super.getConfigLocations();
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext

@Override @Nullable public String getNamespace()

{
    return this.namespace;
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext

@Override protected Resource getResourceByPath(String path)

{
    Assert.state(this.servletContext != null, "No ServletContext available");
    return new ServletContextResource(this.servletContext, path);
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext

@Override protected ResourcePatternResolver getResourcePatternResolver()

{
    return new ServletContextResourcePatternResolver(this);
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext

@Override @Nullable public ServletConfig getServletConfig()

{
    return this.servletConfig;
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext

@Override @Nullable public ServletContext getServletContext()

{
    return this.servletContext;
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext

@Override @Nullable public Theme getTheme(String themeName)

{
    Assert.state(this.themeSource != null, "No ThemeSource available");
    return this.themeSource.getTheme(themeName);
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext

@Override protected void onRefresh()

{
    this.themeSource = UiApplicationContextUtils.initThemeSource(this);
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext

@Override public void setNamespace(@Nullable String namespace)

{
    this.namespace = namespace;
    if (namespace != null) {
        setDisplayName("WebApplicationContext for namespace '" + namespace + "'");
    } 
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext

@Override public void setServletConfig(@Nullable ServletConfig servletConfig)

{
    this.servletConfig = servletConfig;
    if (servletConfig != null && this.servletContext == null) {
        setServletContext(servletConfig.getServletContext());
    } 
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext

@Override public void setServletContext(@Nullable ServletContext servletContext)

{
    this.servletContext = servletContext;
}

AnnotationConfigWebApplicationContext
extends AbstractRefreshableWebApplicationContext implements AnnotationConfigRegistry

org.springframework.web.context.support.AnnotationConfigWebApplicationContext

protected AnnotatedBeanDefinitionReader getAnnotatedBeanDefinitionReader(DefaultListableBeanFactory beanFactory)

{
    return new AnnotatedBeanDefinitionReader(beanFactory, getEnvironment());
}
org.springframework.web.context.support.AnnotationConfigWebApplicationContext

@Nullable protected BeanNameGenerator getBeanNameGenerator()

{
    return this.beanNameGenerator;
}
org.springframework.web.context.support.AnnotationConfigWebApplicationContext

protected ClassPathBeanDefinitionScanner getClassPathBeanDefinitionScanner(DefaultListableBeanFactory beanFactory)

{
    return new ClassPathBeanDefinitionScanner(beanFactory, true, getEnvironment());
}
org.springframework.web.context.support.AnnotationConfigWebApplicationContext

@Nullable protected ScopeMetadataResolver getScopeMetadataResolver()

{
    return this.scopeMetadataResolver;
}
org.springframework.web.context.support.AnnotationConfigWebApplicationContext

@Override protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)

{
    AnnotatedBeanDefinitionReader reader = getAnnotatedBeanDefinitionReader(beanFactory);
    ClassPathBeanDefinitionScanner scanner = getClassPathBeanDefinitionScanner(beanFactory);
    BeanNameGenerator beanNameGenerator = getBeanNameGenerator();
    if (beanNameGenerator != null) {
        reader.setBeanNameGenerator(beanNameGenerator);
        scanner.setBeanNameGenerator(beanNameGenerator);
        beanFactory.registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator);
    } 
    ScopeMetadataResolver scopeMetadataResolver = getScopeMetadataResolver();
    if (scopeMetadataResolver != null) {
        reader.setScopeMetadataResolver(scopeMetadataResolver);
        scanner.setScopeMetadataResolver(scopeMetadataResolver);
    } 
    if (!this.componentClasses.isEmpty()) {
        if (logger.isDebugEnabled()) {
            logger.debug("Registering component classes: [" + StringUtils.collectionToCommaDelimitedString(this.componentClasses) + "]");
        } 
        reader.register(ClassUtils.toClassArray(this.componentClasses));
    } 
    if (!this.basePackages.isEmpty()) {
        if (logger.isDebugEnabled()) {
            logger.debug("Scanning base packages: [" + StringUtils.collectionToCommaDelimitedString(this.basePackages) + "]");
        } 
        scanner.scan(StringUtils.toStringArray(this.basePackages));
    } 
    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
        for (String configLocation: configLocations) {
            try {
                Class<?> clazz = ClassUtils.forName(configLocation, getClassLoader());
                if (logger.isTraceEnabled()) {
                    logger.trace("Registering [" + configLocation + "]");
                } 
                reader.register(clazz);
            } catch (ClassNotFoundException ex) {
                if (logger.isTraceEnabled()) {
                    logger.trace("Could not load class for config location [" + configLocation + "] - trying package scan. " + ex);
                } 
                int count = scanner.scan(configLocation);
                if (count == 0 && logger.isDebugEnabled()) {
                    logger.debug("No component classes found for specified class/package [" + configLocation + "]");
                } 
            }
        }
    } 
}
org.springframework.web.context.support.AnnotationConfigWebApplicationContext

@Override public void register(Class<?>... componentClasses)

{
    Assert.notEmpty(componentClasses, "At least one component class must be specified");
    Collections.addAll(this.componentClasses, componentClasses);
}
org.springframework.web.context.support.AnnotationConfigWebApplicationContext

@Override public void scan(String... basePackages)

{
    Assert.notEmpty(basePackages, "At least one base package must be specified");
    Collections.addAll(this.basePackages, basePackages);
}
org.springframework.web.context.support.AnnotationConfigWebApplicationContext

public void setBeanNameGenerator(@Nullable BeanNameGenerator beanNameGenerator)

{
    this.beanNameGenerator = beanNameGenerator;
}
org.springframework.web.context.support.AnnotationConfigWebApplicationContext

public void setScopeMetadataResolver(@Nullable ScopeMetadataResolver scopeMetadataResolver)

{
    this.scopeMetadataResolver = scopeMetadataResolver;
}

ContextExposingHttpServletRequest
extends HttpServletRequestWrapper

org.springframework.web.context.support.ContextExposingHttpServletRequest

public ContextExposingHttpServletRequest ContextExposingHttpServletRequest(HttpServletRequest originalRequest, WebApplicationContext context)

{
    this(originalRequest, context, null);
}
org.springframework.web.context.support.ContextExposingHttpServletRequest

public ContextExposingHttpServletRequest ContextExposingHttpServletRequest(HttpServletRequest originalRequest, WebApplicationContext context, @Nullable Set<String> exposedContextBeanNames)

{
    super(originalRequest);
    Assert.notNull(context, "WebApplicationContext must not be null");
    this.webApplicationContext = context;
    this.exposedContextBeanNames = exposedContextBeanNames;
}
org.springframework.web.context.support.ContextExposingHttpServletRequest

public final WebApplicationContext getWebApplicationContext()

{
    return this.webApplicationContext;
}
org.springframework.web.context.support.ContextExposingHttpServletRequest

@Override public void setAttribute(String name, Object value)

{
    super.setAttribute(name, value);
    if (this.explicitAttributes == null) {
        this.explicitAttributes = new HashSet<>(8);
    } 
    this.explicitAttributes.add(name);
}

GenericWebApplicationContext
extends GenericApplicationContext implements ConfigurableWebApplicationContext, ThemeSource

org.springframework.web.context.support.GenericWebApplicationContext

public GenericWebApplicationContext GenericWebApplicationContext()

{
    super();
}
org.springframework.web.context.support.GenericWebApplicationContext

public GenericWebApplicationContext GenericWebApplicationContext(ServletContext servletContext)

{
    this.servletContext = servletContext;
}
org.springframework.web.context.support.GenericWebApplicationContext

public GenericWebApplicationContext GenericWebApplicationContext(DefaultListableBeanFactory beanFactory)

{
    super(beanFactory);
}
org.springframework.web.context.support.GenericWebApplicationContext

public GenericWebApplicationContext GenericWebApplicationContext(DefaultListableBeanFactory beanFactory, ServletContext servletContext)

{
    super(beanFactory);
    this.servletContext = servletContext;
}
org.springframework.web.context.support.GenericWebApplicationContext

@Override protected ConfigurableEnvironment createEnvironment()

{
    return new StandardServletEnvironment();
}
org.springframework.web.context.support.GenericWebApplicationContext

@Override public String getApplicationName()

{
    return (this.servletContext != null ? this.servletContext.getContextPath() : "");
}
org.springframework.web.context.support.GenericWebApplicationContext

@Override public String[] getConfigLocations()

{
    throw new UnsupportedOperationException("GenericWebApplicationContext does not support getConfigLocations()");
}
org.springframework.web.context.support.GenericWebApplicationContext

@Override @Nullable public String getNamespace()

{
    throw new UnsupportedOperationException("GenericWebApplicationContext does not support getNamespace()");
}
org.springframework.web.context.support.GenericWebApplicationContext

@Override protected Resource getResourceByPath(String path)

{
    Assert.state(this.servletContext != null, "No ServletContext available");
    return new ServletContextResource(this.servletContext, path);
}
org.springframework.web.context.support.GenericWebApplicationContext

@Override protected ResourcePatternResolver getResourcePatternResolver()

{
    return new ServletContextResourcePatternResolver(this);
}
org.springframework.web.context.support.GenericWebApplicationContext

@Override @Nullable public ServletConfig getServletConfig()

{
    throw new UnsupportedOperationException("GenericWebApplicationContext does not support getServletConfig()");
}
org.springframework.web.context.support.GenericWebApplicationContext

@Override @Nullable public ServletContext getServletContext()

{
    return this.servletContext;
}
org.springframework.web.context.support.GenericWebApplicationContext

@Override @Nullable public Theme getTheme(String themeName)

{
    Assert.state(this.themeSource != null, "No ThemeSource available");
    return this.themeSource.getTheme(themeName);
}
org.springframework.web.context.support.GenericWebApplicationContext

@Override protected void onRefresh()

{
    this.themeSource = UiApplicationContextUtils.initThemeSource(this);
}
org.springframework.web.context.support.GenericWebApplicationContext

@Override protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)

{
    if (this.servletContext != null) {
        beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext));
        beanFactory.ignoreDependencyInterface(ServletContextAware.class);
    } 
    WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
    WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext);
}
org.springframework.web.context.support.GenericWebApplicationContext

@Override public void setNamespace(@Nullable String namespace)

{
}
org.springframework.web.context.support.GenericWebApplicationContext

@Override public void setServletConfig(@Nullable ServletConfig servletConfig)

{
}
org.springframework.web.context.support.GenericWebApplicationContext

@Override public void setServletContext(@Nullable ServletContext servletContext)

{
    this.servletContext = servletContext;
}

GroovyWebApplicationContext
extends AbstractRefreshableWebApplicationContext implements GroovyObject

org.springframework.web.context.support.GroovyWebApplicationContext

public static final String DEFAULT_CONFIG_LOCATION

org.springframework.web.context.support.GroovyWebApplicationContext

public static final String DEFAULT_CONFIG_LOCATION_PREFIX

org.springframework.web.context.support.GroovyWebApplicationContext

public static final String DEFAULT_CONFIG_LOCATION_SUFFIX

org.springframework.web.context.support.GroovyWebApplicationContext

@Override protected String[] getDefaultConfigLocations()

{
    if (getNamespace() != null) {
        return new String[]{DEFAULT_CONFIG_LOCATION_PREFIX + getNamespace() + DEFAULT_CONFIG_LOCATION_SUFFIX};
    } else {
        return new String[]{DEFAULT_CONFIG_LOCATION};
    }
}
org.springframework.web.context.support.GroovyWebApplicationContext

@Override public MetaClass getMetaClass()

{
    return this.metaClass;
}
org.springframework.web.context.support.GroovyWebApplicationContext

@Override @Nullable public Object getProperty(String property)

{
    if (containsBean(property)) {
        return getBean(property);
    } else if (this.contextWrapper.isReadableProperty(property)) {
        return this.contextWrapper.getPropertyValue(property);
    } 
    throw new NoSuchBeanDefinitionException(property);
}
org.springframework.web.context.support.GroovyWebApplicationContext

protected void initBeanDefinitionReader(GroovyBeanDefinitionReader beanDefinitionReader)

{
}
org.springframework.web.context.support.GroovyWebApplicationContext

@Override public Object invokeMethod(String name, Object args)

{
    return this.metaClass.invokeMethod(this, name, args);
}
org.springframework.web.context.support.GroovyWebApplicationContext

protected void loadBeanDefinitions(GroovyBeanDefinitionReader reader)

{
    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
        for (String configLocation: configLocations) {
            reader.loadBeanDefinitions(configLocation);
        }
    } 
}
org.springframework.web.context.support.GroovyWebApplicationContext

@Override public void setMetaClass(MetaClass metaClass)

{
    this.metaClass = metaClass;
}
org.springframework.web.context.support.GroovyWebApplicationContext

@Override public void setProperty(String property, Object newValue)

{
    this.metaClass.setProperty(this, property, newValue);
}

HttpRequestHandlerServlet
extends HttpServlet

org.springframework.web.context.support.HttpRequestHandlerServlet

@Override protected void service(HttpServletRequest request, HttpServletResponse response)

{
    Assert.state(this.target != null, "No HttpRequestHandler available");
    LocaleContextHolder.setLocale(request.getLocale());
    try {
        this.target.handleRequest(request, response);
    } catch (HttpRequestMethodNotSupportedException ex) {
        String[] supportedMethods = ex.getSupportedMethods();
        if (supportedMethods != null) {
            response.setHeader("Allow", StringUtils.arrayToDelimitedString(supportedMethods, ", "));
        } 
        response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, ex.getMessage());
    } finally {
        LocaleContextHolder.resetLocaleContext();
    }
}

LiveBeansViewServlet
extends HttpServlet

org.springframework.web.context.support.LiveBeansViewServlet

protected LiveBeansView buildLiveBeansView()

{
    return new ServletContextLiveBeansView(getServletContext());
}
org.springframework.web.context.support.LiveBeansViewServlet

@Override public void init()

{
    this.liveBeansView = buildLiveBeansView();
}

RequestHandledEvent
extends ApplicationEvent

org.springframework.web.context.support.RequestHandledEvent

public RequestHandledEvent RequestHandledEvent(Object source, @Nullable String sessionId, @Nullable String userName, long processingTimeMillis)

{
    super(source);
    this.sessionId = sessionId;
    this.userName = userName;
    this.processingTimeMillis = processingTimeMillis;
}
org.springframework.web.context.support.RequestHandledEvent

public RequestHandledEvent RequestHandledEvent(Object source, @Nullable String sessionId, @Nullable String userName, long processingTimeMillis, @Nullable Throwable failureCause)

{
    this(source, sessionId, userName, processingTimeMillis);
    this.failureCause = failureCause;
}
org.springframework.web.context.support.RequestHandledEvent

@Nullable public Throwable getFailureCause()

{
    return this.failureCause;
}
org.springframework.web.context.support.RequestHandledEvent

public long getProcessingTimeMillis()

{
    return this.processingTimeMillis;
}
org.springframework.web.context.support.RequestHandledEvent

@Nullable public String getSessionId()

{
    return this.sessionId;
}
org.springframework.web.context.support.RequestHandledEvent

@Nullable public String getUserName()

{
    return this.userName;
}
org.springframework.web.context.support.RequestHandledEvent

@Override public String toString()

{
    return ("RequestHandledEvent: " + getDescription());
}
org.springframework.web.context.support.RequestHandledEvent

public boolean wasFailure()

{
    return (this.failureCause != null);
}

ServletConfigPropertySource
extends EnumerablePropertySource<ServletConfig>

org.springframework.web.context.support.ServletConfigPropertySource

public ServletConfigPropertySource ServletConfigPropertySource(String name, ServletConfig servletConfig)

{
    super(name, servletConfig);
}
org.springframework.web.context.support.ServletConfigPropertySource

@Override @Nullable public String getProperty(String name)

{
    return this.source.getInitParameter(name);
}
org.springframework.web.context.support.ServletConfigPropertySource

@Override public String[] getPropertyNames()

{
    return StringUtils.toStringArray(this.source.getInitParameterNames());
}

ServletContextAttributeExporter
implements ServletContextAware

org.springframework.web.context.support.ServletContextAttributeExporter

protected final Log logger

org.springframework.web.context.support.ServletContextAttributeExporter

public void setAttributes(Map<String, Object> attributes)

{
    this.attributes = attributes;
}

ServletContextAttributeFactoryBean
implements FactoryBean<Object>, ServletContextAware

org.springframework.web.context.support.ServletContextAttributeFactoryBean

@Override @Nullable public Object getObject()

{
    return this.attribute;
}
org.springframework.web.context.support.ServletContextAttributeFactoryBean

@Override public Class<?> getObjectType()

{
    return (this.attribute != null ? this.attribute.getClass() : null);
}
org.springframework.web.context.support.ServletContextAttributeFactoryBean

@Override public boolean isSingleton()

{
    return true;
}
org.springframework.web.context.support.ServletContextAttributeFactoryBean

public void setAttributeName(String attributeName)

{
    this.attributeName = attributeName;
}
org.springframework.web.context.support.ServletContextAttributeFactoryBean

@Override public void setServletContext(ServletContext servletContext)

{
    if (this.attributeName == null) {
        throw new IllegalArgumentException("Property 'attributeName' is required");
    } 
    this.attribute = servletContext.getAttribute(this.attributeName);
    if (this.attribute == null) {
        throw new IllegalStateException("No ServletContext attribute '" + this.attributeName + "' found");
    } 
}

ServletContextAwareProcessor
implements BeanPostProcessor

org.springframework.web.context.support.ServletContextAwareProcessor

protected ServletContextAwareProcessor ServletContextAwareProcessor()

{
}
org.springframework.web.context.support.ServletContextAwareProcessor

public ServletContextAwareProcessor ServletContextAwareProcessor(ServletContext servletContext)

{
    this(servletContext, null);
}
org.springframework.web.context.support.ServletContextAwareProcessor

public ServletContextAwareProcessor ServletContextAwareProcessor(ServletConfig servletConfig)

{
    this(null, servletConfig);
}
org.springframework.web.context.support.ServletContextAwareProcessor

public ServletContextAwareProcessor ServletContextAwareProcessor(@Nullable ServletContext servletContext, @Nullable ServletConfig servletConfig)

{
    this.servletContext = servletContext;
    this.servletConfig = servletConfig;
}
org.springframework.web.context.support.ServletContextAwareProcessor

@Nullable protected ServletConfig getServletConfig()

{
    return this.servletConfig;
}
org.springframework.web.context.support.ServletContextAwareProcessor

@Nullable protected ServletContext getServletContext()

{
    if (this.servletContext == null && getServletConfig() != null) {
        return getServletConfig().getServletContext();
    } 
    return this.servletContext;
}
org.springframework.web.context.support.ServletContextAwareProcessor

@Override public Object postProcessAfterInitialization(Object bean, String beanName)

{
    return bean;
}
org.springframework.web.context.support.ServletContextAwareProcessor

@Override public Object postProcessBeforeInitialization(Object bean, String beanName)

{
    if (getServletContext() != null && bean instanceof ServletContextAware) {
        ((ServletContextAware)bean).setServletContext(getServletContext());
    } 
    if (getServletConfig() != null && bean instanceof ServletConfigAware) {
        ((ServletConfigAware)bean).setServletConfig(getServletConfig());
    } 
    return bean;
}

ServletContextLiveBeansView
extends LiveBeansView

org.springframework.web.context.support.ServletContextLiveBeansView

public ServletContextLiveBeansView ServletContextLiveBeansView(ServletContext servletContext)

{
    Assert.notNull(servletContext, "ServletContext must not be null");
    this.servletContext = servletContext;
}

ServletContextParameterFactoryBean
implements FactoryBean<String>, ServletContextAware

org.springframework.web.context.support.ServletContextParameterFactoryBean

@Override @Nullable public String getObject()

{
    return this.paramValue;
}
org.springframework.web.context.support.ServletContextParameterFactoryBean

@Override public Class<String> getObjectType()

{
    return String.class;
}
org.springframework.web.context.support.ServletContextParameterFactoryBean

@Override public boolean isSingleton()

{
    return true;
}
org.springframework.web.context.support.ServletContextParameterFactoryBean

public void setInitParamName(String initParamName)

{
    this.initParamName = initParamName;
}
org.springframework.web.context.support.ServletContextParameterFactoryBean

@Override public void setServletContext(ServletContext servletContext)

{
    if (this.initParamName == null) {
        throw new IllegalArgumentException("initParamName is required");
    } 
    this.paramValue = servletContext.getInitParameter(this.initParamName);
    if (this.paramValue == null) {
        throw new IllegalStateException("No ServletContext init parameter '" + this.initParamName + "' found");
    } 
}

ServletContextPropertySource
extends EnumerablePropertySource<ServletContext>

org.springframework.web.context.support.ServletContextPropertySource

public ServletContextPropertySource ServletContextPropertySource(String name, ServletContext servletContext)

{
    super(name, servletContext);
}
org.springframework.web.context.support.ServletContextPropertySource

@Override @Nullable public String getProperty(String name)

{
    return this.source.getInitParameter(name);
}
org.springframework.web.context.support.ServletContextPropertySource

@Override public String[] getPropertyNames()

{
    return StringUtils.toStringArray(this.source.getInitParameterNames());
}

ServletContextResource
extends AbstractFileResolvingResource implements ContextResource

org.springframework.web.context.support.ServletContextResource

@Override public Resource createRelative(String relativePath)

{
    String pathToUse = StringUtils.applyRelativePath(this.path, relativePath);
    return new ServletContextResource(this.servletContext, pathToUse);
}
org.springframework.web.context.support.ServletContextResource

@Override public boolean equals(@Nullable Object other)

{
    if (this == other) {
        return true;
    } 
    if (!(other instanceof ServletContextResource)) {
        return false;
    } 
    ServletContextResource otherRes = (ServletContextResource)other;
    return (this.servletContext.equals(otherRes.servletContext) && this.path.equals(otherRes.path));
}
org.springframework.web.context.support.ServletContextResource

@Override public boolean exists()

{
    try {
        URL url = this.servletContext.getResource(this.path);
        return (url != null);
    } catch (MalformedURLException ex) {
        return false;
    }
}
org.springframework.web.context.support.ServletContextResource

@Override public String getDescription()

{
    return "ServletContext resource [" + this.path + "]";
}
org.springframework.web.context.support.ServletContextResource

@Override @Nullable public String getFilename()

{
    return StringUtils.getFilename(this.path);
}
org.springframework.web.context.support.ServletContextResource

@Override public InputStream getInputStream()

{
    InputStream is = this.servletContext.getResourceAsStream(this.path);
    if (is == null) {
        throw new FileNotFoundException("Could not open " + getDescription());
    } 
    return is;
}
org.springframework.web.context.support.ServletContextResource

public final String getPath()

{
    return this.path;
}
org.springframework.web.context.support.ServletContextResource

@Override public String getPathWithinContext()

{
    return this.path;
}
org.springframework.web.context.support.ServletContextResource

public final ServletContext getServletContext()

{
    return this.servletContext;
}
org.springframework.web.context.support.ServletContextResource

@Override public int hashCode()

{
    return this.path.hashCode();
}
org.springframework.web.context.support.ServletContextResource

@Override public boolean isFile()

{
    try {
        URL url = this.servletContext.getResource(this.path);
        if (url != null && ResourceUtils.isFileURL(url)) {
            return true;
        } else {
            return (this.servletContext.getRealPath(this.path) != null);
        }
    } catch (MalformedURLException ex) {
        return false;
    }
}
org.springframework.web.context.support.ServletContextResource

@Override public boolean isReadable()

{
    InputStream is = this.servletContext.getResourceAsStream(this.path);
    if (is != null) {
        try {
            is.close();
        } catch (IOException ex) {
        }
        return true;
    } else {
        return false;
    }
}

ServletContextResourceLoader
extends DefaultResourceLoader

org.springframework.web.context.support.ServletContextResourceLoader

public ServletContextResourceLoader ServletContextResourceLoader(ServletContext servletContext)

{
    this.servletContext = servletContext;
}
org.springframework.web.context.support.ServletContextResourceLoader

@Override protected Resource getResourceByPath(String path)

{
    return new ServletContextResource(this.servletContext, path);
}

ServletContextResourcePatternResolver
extends PathMatchingResourcePatternResolver

org.springframework.web.context.support.ServletContextResourcePatternResolver

public ServletContextResourcePatternResolver ServletContextResourcePatternResolver(ServletContext servletContext)

{
    super(new ServletContextResourceLoader(servletContext));
}
org.springframework.web.context.support.ServletContextResourcePatternResolver

public ServletContextResourcePatternResolver ServletContextResourcePatternResolver(ResourceLoader resourceLoader)

{
    super(resourceLoader);
}
org.springframework.web.context.support.ServletContextResourcePatternResolver

protected void doRetrieveMatchingServletContextResources(ServletContext servletContext, String fullPattern, String dir, Set<Resource> result)

{
    Set<String> candidates = servletContext.getResourcePaths(dir);
    if (candidates != null) {
        boolean dirDepthNotFixed = fullPattern.contains("**");
        int jarFileSep = fullPattern.indexOf(ResourceUtils.JAR_URL_SEPARATOR);
        String jarFilePath = null;
        String pathInJarFile = null;
        if (jarFileSep > 0 && jarFileSep + ResourceUtils.JAR_URL_SEPARATOR.length() < fullPattern.length()) {
            jarFilePath = fullPattern.substring(0, jarFileSep);
            pathInJarFile = fullPattern.substring(jarFileSep + ResourceUtils.JAR_URL_SEPARATOR.length());
        } 
        for (String currPath: candidates) {
            if (!currPath.startsWith(dir)) {
                int dirIndex = currPath.indexOf(dir);
                if (dirIndex != -1) {
                    currPath = currPath.substring(dirIndex);
                } 
            } 
            if (currPath.endsWith("/") && (dirDepthNotFixed || StringUtils.countOccurrencesOf(currPath, "/") <= StringUtils.countOccurrencesOf(fullPattern, "/"))) {
                doRetrieveMatchingServletContextResources(servletContext, fullPattern, currPath, result);
            } 
            if (jarFilePath != null && getPathMatcher().match(jarFilePath, currPath)) {
                String absoluteJarPath = servletContext.getRealPath(currPath);
                if (absoluteJarPath != null) {
                    doRetrieveMatchingJarEntries(absoluteJarPath, pathInJarFile, result);
                } 
            } 
            if (getPathMatcher().match(fullPattern, currPath)) {
                result.add(new ServletContextResource(servletContext, currPath));
            } 
        }
    } 
}

ServletContextScope
implements Scope, DisposableBean

org.springframework.web.context.support.ServletContextScope

public ServletContextScope ServletContextScope(ServletContext servletContext)

{
    Assert.notNull(servletContext, "ServletContext must not be null");
    this.servletContext = servletContext;
}
org.springframework.web.context.support.ServletContextScope

@Override public void destroy()

{
    synchronized(this.destructionCallbacks) {
        for (Runnable runnable: this.destructionCallbacks.values()) {
            runnable.run();
        }
        this.destructionCallbacks.clear();
    }
}
org.springframework.web.context.support.ServletContextScope

@Override public Object get(String name, ObjectFactory<?> objectFactory)

{
    Object scopedObject = this.servletContext.getAttribute(name);
    if (scopedObject == null) {
        scopedObject = objectFactory.getObject();
        this.servletContext.setAttribute(name, scopedObject);
    } 
    return scopedObject;
}
org.springframework.web.context.support.ServletContextScope

@Override @Nullable public String getConversationId()

{
    return null;
}
org.springframework.web.context.support.ServletContextScope

@Override public void registerDestructionCallback(String name, Runnable callback)

{
    synchronized(this.destructionCallbacks) {
        this.destructionCallbacks.put(name, callback);
    }
}
org.springframework.web.context.support.ServletContextScope

@Override @Nullable public Object remove(String name)

{
    Object scopedObject = this.servletContext.getAttribute(name);
    if (scopedObject != null) {
        synchronized(this.destructionCallbacks) {
            this.destructionCallbacks.remove(name);
        }
        this.servletContext.removeAttribute(name);
        return scopedObject;
    } else {
        return null;
    }
}
org.springframework.web.context.support.ServletContextScope

@Override @Nullable public Object resolveContextualObject(String key)

{
    return null;
}

ServletRequestHandledEvent
extends RequestHandledEvent

org.springframework.web.context.support.ServletRequestHandledEvent

public ServletRequestHandledEvent ServletRequestHandledEvent(Object source, String requestUrl, String clientAddress, String method, String servletName, @Nullable String sessionId, @Nullable String userName, long processingTimeMillis)

{
    super(source, sessionId, userName, processingTimeMillis);
    this.requestUrl = requestUrl;
    this.clientAddress = clientAddress;
    this.method = method;
    this.servletName = servletName;
    this.statusCode = -1;
}
org.springframework.web.context.support.ServletRequestHandledEvent

public ServletRequestHandledEvent ServletRequestHandledEvent(Object source, String requestUrl, String clientAddress, String method, String servletName, @Nullable String sessionId, @Nullable String userName, long processingTimeMillis, @Nullable Throwable failureCause)

{
    super(source, sessionId, userName, processingTimeMillis, failureCause);
    this.requestUrl = requestUrl;
    this.clientAddress = clientAddress;
    this.method = method;
    this.servletName = servletName;
    this.statusCode = -1;
}
org.springframework.web.context.support.ServletRequestHandledEvent

public ServletRequestHandledEvent ServletRequestHandledEvent(Object source, String requestUrl, String clientAddress, String method, String servletName, @Nullable String sessionId, @Nullable String userName, long processingTimeMillis, @Nullable Throwable failureCause, int statusCode)

{
    super(source, sessionId, userName, processingTimeMillis, failureCause);
    this.requestUrl = requestUrl;
    this.clientAddress = clientAddress;
    this.method = method;
    this.servletName = servletName;
    this.statusCode = statusCode;
}
org.springframework.web.context.support.ServletRequestHandledEvent

public String getClientAddress()

{
    return this.clientAddress;
}
org.springframework.web.context.support.ServletRequestHandledEvent

public String getMethod()

{
    return this.method;
}
org.springframework.web.context.support.ServletRequestHandledEvent

public String getRequestUrl()

{
    return this.requestUrl;
}
org.springframework.web.context.support.ServletRequestHandledEvent

public String getServletName()

{
    return this.servletName;
}
org.springframework.web.context.support.ServletRequestHandledEvent

public int getStatusCode()

{
    return this.statusCode;
}
org.springframework.web.context.support.ServletRequestHandledEvent

@Override public String toString()

{
    return "ServletRequestHandledEvent: " + getDescription();
}

StandardServletEnvironment
extends StandardEnvironment implements ConfigurableWebEnvironment

org.springframework.web.context.support.StandardServletEnvironment

public static final String JNDI_PROPERTY_SOURCE_NAME

org.springframework.web.context.support.StandardServletEnvironment

public static final String SERVLET_CONFIG_PROPERTY_SOURCE_NAME

org.springframework.web.context.support.StandardServletEnvironment

public static final String SERVLET_CONTEXT_PROPERTY_SOURCE_NAME

org.springframework.web.context.support.StandardServletEnvironment

@Override public void initPropertySources(@Nullable ServletContext servletContext, @Nullable ServletConfig servletConfig)

{
    WebApplicationContextUtils.initServletPropertySources(getPropertySources(), servletContext, servletConfig);
}

StaticWebApplicationContext
extends StaticApplicationContext implements ConfigurableWebApplicationContext, ThemeSource

org.springframework.web.context.support.StaticWebApplicationContext

public StaticWebApplicationContext StaticWebApplicationContext()

{
    setDisplayName("Root WebApplicationContext");
}
org.springframework.web.context.support.StaticWebApplicationContext

@Override protected ConfigurableEnvironment createEnvironment()

{
    return new StandardServletEnvironment();
}
org.springframework.web.context.support.StaticWebApplicationContext

@Override public String[] getConfigLocations()

{
    return null;
}
org.springframework.web.context.support.StaticWebApplicationContext

@Override @Nullable public String getNamespace()

{
    return this.namespace;
}
org.springframework.web.context.support.StaticWebApplicationContext

@Override protected Resource getResourceByPath(String path)

{
    Assert.state(this.servletContext != null, "No ServletContext available");
    return new ServletContextResource(this.servletContext, path);
}
org.springframework.web.context.support.StaticWebApplicationContext

@Override protected ResourcePatternResolver getResourcePatternResolver()

{
    return new ServletContextResourcePatternResolver(this);
}
org.springframework.web.context.support.StaticWebApplicationContext

@Override @Nullable public ServletConfig getServletConfig()

{
    return this.servletConfig;
}
org.springframework.web.context.support.StaticWebApplicationContext

@Override @Nullable public ServletContext getServletContext()

{
    return this.servletContext;
}
org.springframework.web.context.support.StaticWebApplicationContext

@Override @Nullable public Theme getTheme(String themeName)

{
    Assert.state(this.themeSource != null, "No ThemeSource available");
    return this.themeSource.getTheme(themeName);
}
org.springframework.web.context.support.StaticWebApplicationContext

@Override protected void initPropertySources()

{
    WebApplicationContextUtils.initServletPropertySources(getEnvironment().getPropertySources(), this.servletContext, this.servletConfig);
}
org.springframework.web.context.support.StaticWebApplicationContext

@Override protected void onRefresh()

{
    this.themeSource = UiApplicationContextUtils.initThemeSource(this);
}
org.springframework.web.context.support.StaticWebApplicationContext

@Override public void setConfigLocation(String configLocation)

{
    throw new UnsupportedOperationException("StaticWebApplicationContext does not support config locations");
}
org.springframework.web.context.support.StaticWebApplicationContext

@Override public void setConfigLocations(String... configLocations)

{
    throw new UnsupportedOperationException("StaticWebApplicationContext does not support config locations");
}
org.springframework.web.context.support.StaticWebApplicationContext

@Override public void setNamespace(@Nullable String namespace)

{
    this.namespace = namespace;
    if (namespace != null) {
        setDisplayName("WebApplicationContext for namespace '" + namespace + "'");
    } 
}
org.springframework.web.context.support.StaticWebApplicationContext

@Override public void setServletConfig(@Nullable ServletConfig servletConfig)

{
    this.servletConfig = servletConfig;
    if (servletConfig != null && this.servletContext == null) {
        this.servletContext = servletConfig.getServletContext();
    } 
}
org.springframework.web.context.support.StaticWebApplicationContext

@Override public void setServletContext(@Nullable ServletContext servletContext)

{
    this.servletContext = servletContext;
}

WebApplicationContextUtils

org.springframework.web.context.support.WebApplicationContextUtils

public static WebApplicationContext getRequiredWebApplicationContext(ServletContext sc)

{
    WebApplicationContext wac = getWebApplicationContext(sc);
    if (wac == null) {
        throw new IllegalStateException("No WebApplicationContext found: no ContextLoaderListener registered?");
    } 
    return wac;
}
org.springframework.web.context.support.WebApplicationContextUtils

@Nullable public static WebApplicationContext getWebApplicationContext(ServletContext sc)

{
    return getWebApplicationContext(sc, WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
}
org.springframework.web.context.support.WebApplicationContextUtils

@Nullable public static WebApplicationContext getWebApplicationContext(ServletContext sc, String attrName)

{
    Assert.notNull(sc, "ServletContext must not be null");
    Object attr = sc.getAttribute(attrName);
    if (attr == null) {
        return null;
    } 
    if (attr instanceof RuntimeException) {
        throw (RuntimeException)attr;
    } 
    if (attr instanceof Error) {
        throw (Error)attr;
    } 
    if (attr instanceof Exception) {
        throw new IllegalStateException((Exception)attr);
    } 
    if (!(attr instanceof WebApplicationContext)) {
        throw new IllegalStateException("Context attribute is not of type WebApplicationContext: " + attr);
    } 
    return (WebApplicationContext)attr;
}
org.springframework.web.context.support.WebApplicationContextUtils

public static void initServletPropertySources(MutablePropertySources propertySources, ServletContext servletContext)

{
    initServletPropertySources(propertySources, servletContext, null);
}
org.springframework.web.context.support.WebApplicationContextUtils

public static void initServletPropertySources(MutablePropertySources sources, @Nullable ServletContext servletContext, @Nullable ServletConfig servletConfig)

{
    Assert.notNull(sources, "'propertySources' must not be null");
    String name = StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME;
    if (servletContext != null && sources.contains(name) && sources.get(name) instanceof StubPropertySource) {
        sources.replace(name, new ServletContextPropertySource(name, servletContext));
    } 
    name = StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME;
    if (servletConfig != null && sources.contains(name) && sources.get(name) instanceof StubPropertySource) {
        sources.replace(name, new ServletConfigPropertySource(name, servletConfig));
    } 
}
org.springframework.web.context.support.WebApplicationContextUtils

public static void registerEnvironmentBeans(ConfigurableListableBeanFactory bf, @Nullable ServletContext sc)

{
    registerEnvironmentBeans(bf, sc, null);
}
org.springframework.web.context.support.WebApplicationContextUtils

public static void registerEnvironmentBeans(ConfigurableListableBeanFactory bf, @Nullable ServletContext servletContext, @Nullable ServletConfig servletConfig)

{
    if (servletContext != null && !bf.containsBean(WebApplicationContext.SERVLET_CONTEXT_BEAN_NAME)) {
        bf.registerSingleton(WebApplicationContext.SERVLET_CONTEXT_BEAN_NAME, servletContext);
    } 
    if (servletConfig != null && !bf.containsBean(ConfigurableWebApplicationContext.SERVLET_CONFIG_BEAN_NAME)) {
        bf.registerSingleton(ConfigurableWebApplicationContext.SERVLET_CONFIG_BEAN_NAME, servletConfig);
    } 
    if (!bf.containsBean(WebApplicationContext.CONTEXT_PARAMETERS_BEAN_NAME)) {
        Map<String, String> parameterMap = new HashMap<>();
        if (servletContext != null) {
            Enumeration<?> paramNameEnum = servletContext.getInitParameterNames();
            while (paramNameEnum.hasMoreElements()) {
                String paramName = (String)paramNameEnum.nextElement();
                parameterMap.put(paramName, servletContext.getInitParameter(paramName));
            }
        } 
        if (servletConfig != null) {
            Enumeration<?> paramNameEnum = servletConfig.getInitParameterNames();
            while (paramNameEnum.hasMoreElements()) {
                String paramName = (String)paramNameEnum.nextElement();
                parameterMap.put(paramName, servletConfig.getInitParameter(paramName));
            }
        } 
        bf.registerSingleton(WebApplicationContext.CONTEXT_PARAMETERS_BEAN_NAME, Collections.unmodifiableMap(parameterMap));
    } 
    if (!bf.containsBean(WebApplicationContext.CONTEXT_ATTRIBUTES_BEAN_NAME)) {
        Map<String, Object> attributeMap = new HashMap<>();
        if (servletContext != null) {
            Enumeration<?> attrNameEnum = servletContext.getAttributeNames();
            while (attrNameEnum.hasMoreElements()) {
                String attrName = (String)attrNameEnum.nextElement();
                attributeMap.put(attrName, servletContext.getAttribute(attrName));
            }
        } 
        bf.registerSingleton(WebApplicationContext.CONTEXT_ATTRIBUTES_BEAN_NAME, Collections.unmodifiableMap(attributeMap));
    } 
}
org.springframework.web.context.support.WebApplicationContextUtils

public static void registerWebApplicationScopes(ConfigurableListableBeanFactory beanFactory)

{
    registerWebApplicationScopes(beanFactory, null);
}
org.springframework.web.context.support.WebApplicationContextUtils

public static void registerWebApplicationScopes(ConfigurableListableBeanFactory beanFactory, @Nullable ServletContext sc)

{
    beanFactory.registerScope(WebApplicationContext.SCOPE_REQUEST, new RequestScope());
    beanFactory.registerScope(WebApplicationContext.SCOPE_SESSION, new SessionScope());
    if (sc != null) {
        ServletContextScope appScope = new ServletContextScope(sc);
        beanFactory.registerScope(WebApplicationContext.SCOPE_APPLICATION, appScope);
        sc.setAttribute(ServletContextScope.class.getName(), appScope);
    } 
    beanFactory.registerResolvableDependency(ServletRequest.class, new RequestObjectFactory());
    beanFactory.registerResolvableDependency(ServletResponse.class, new ResponseObjectFactory());
    beanFactory.registerResolvableDependency(HttpSession.class, new SessionObjectFactory());
    beanFactory.registerResolvableDependency(WebRequest.class, new WebRequestObjectFactory());
    if (jsfPresent) {
        FacesDependencyRegistrar.registerFacesDependencies(beanFactory);
    } 
}

WebApplicationObjectSupport
extends ApplicationObjectSupport implements ServletContextAware

org.springframework.web.context.support.WebApplicationObjectSupport

@Nullable protected final ServletContext getServletContext()

{
    if (this.servletContext != null) {
        return this.servletContext;
    } 
    ServletContext servletContext = null;
    WebApplicationContext wac = getWebApplicationContext();
    if (wac != null) {
        servletContext = wac.getServletContext();
    } 
    if (servletContext == null && isContextRequired()) {
        throw new IllegalStateException("WebApplicationObjectSupport instance [" + this + "] does not run within a ServletContext. Make sure the object is fully configured!");
    } 
    return servletContext;
}
org.springframework.web.context.support.WebApplicationObjectSupport

protected void initServletContext(ServletContext servletContext)

{
}
org.springframework.web.context.support.WebApplicationObjectSupport

@Override protected boolean isContextRequired()

{
    return true;
}
org.springframework.web.context.support.WebApplicationObjectSupport

@Override public final void setServletContext(ServletContext servletContext)

{
    if (servletContext != this.servletContext) {
        this.servletContext = servletContext;
        initServletContext(servletContext);
    } 
}

XmlWebApplicationContext
extends AbstractRefreshableWebApplicationContext

org.springframework.web.context.support.XmlWebApplicationContext

public static final String DEFAULT_CONFIG_LOCATION

org.springframework.web.context.support.XmlWebApplicationContext

public static final String DEFAULT_CONFIG_LOCATION_PREFIX

org.springframework.web.context.support.XmlWebApplicationContext

public static final String DEFAULT_CONFIG_LOCATION_SUFFIX

org.springframework.web.context.support.XmlWebApplicationContext

@Override protected String[] getDefaultConfigLocations()

{
    if (getNamespace() != null) {
        return new String[]{DEFAULT_CONFIG_LOCATION_PREFIX + getNamespace() + DEFAULT_CONFIG_LOCATION_SUFFIX};
    } else {
        return new String[]{DEFAULT_CONFIG_LOCATION};
    }
}
org.springframework.web.context.support.XmlWebApplicationContext

protected void initBeanDefinitionReader(XmlBeanDefinitionReader beanDefinitionReader)

{
}
org.springframework.web.context.support.XmlWebApplicationContext

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader)

{
    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
        for (String configLocation: configLocations) {
            reader.loadBeanDefinitions(configLocation);
        }
    } 
}


CorsConfiguration

org.springframework.web.cors.CorsConfiguration

public static final String ALL

org.springframework.web.cors.CorsConfiguration

public CorsConfiguration CorsConfiguration()

{
}
org.springframework.web.cors.CorsConfiguration

public void addAllowedHeader(String allowedHeader)

{
    if (this.allowedHeaders == null) {
        this.allowedHeaders = new ArrayList<>(4);
    } else if (this.allowedHeaders == DEFAULT_PERMIT_ALL) {
        setAllowedHeaders(DEFAULT_PERMIT_ALL);
    } 
    this.allowedHeaders.add(allowedHeader);
}
org.springframework.web.cors.CorsConfiguration

public void addAllowedMethod(HttpMethod method)

{
    addAllowedMethod(method.name());
}
org.springframework.web.cors.CorsConfiguration

public void addAllowedMethod(String method)

{
    if (StringUtils.hasText(method)) {
        if (this.allowedMethods == null) {
            this.allowedMethods = new ArrayList<>(4);
            this.resolvedMethods = new ArrayList<>(4);
        } else if (this.allowedMethods == DEFAULT_PERMIT_METHODS) {
            setAllowedMethods(DEFAULT_PERMIT_METHODS);
        } 
        this.allowedMethods.add(method);
        if (ALL.equals(method)) {
            this.resolvedMethods = null;
        } else if (this.resolvedMethods != null) {
            this.resolvedMethods.add(HttpMethod.resolve(method));
        } 
    } 
}
org.springframework.web.cors.CorsConfiguration

public void addAllowedOrigin(String origin)

{
    if (this.allowedOrigins == null) {
        this.allowedOrigins = new ArrayList<>(4);
    } else if (this.allowedOrigins == DEFAULT_PERMIT_ALL) {
        setAllowedOrigins(DEFAULT_PERMIT_ALL);
    } 
    this.allowedOrigins.add(origin);
}
org.springframework.web.cors.CorsConfiguration

public void addExposedHeader(String exposedHeader)

{
    if (ALL.equals(exposedHeader)) {
        throw new IllegalArgumentException("'*' is not a valid exposed header value");
    } 
    if (this.exposedHeaders == null) {
        this.exposedHeaders = new ArrayList<>(4);
    } 
    this.exposedHeaders.add(exposedHeader);
}
org.springframework.web.cors.CorsConfiguration

public CorsConfiguration applyPermitDefaultValues()

{
    if (this.allowedOrigins == null) {
        this.allowedOrigins = DEFAULT_PERMIT_ALL;
    } 
    if (this.allowedMethods == null) {
        this.allowedMethods = DEFAULT_PERMIT_METHODS;
        this.resolvedMethods = DEFAULT_PERMIT_METHODS.stream().map(HttpMethod::resolve).collect(Collectors.toList());
    } 
    if (this.allowedHeaders == null) {
        this.allowedHeaders = DEFAULT_PERMIT_ALL;
    } 
    if (this.maxAge == null) {
        this.maxAge = 1800L;
    } 
    return this;
}
org.springframework.web.cors.CorsConfiguration

@Nullable public List<String> checkHeaders(@Nullable List<String> requestHeaders)

{
    if (requestHeaders == null) {
        return null;
    } 
    if (requestHeaders.isEmpty()) {
        return Collections.emptyList();
    } 
    if (ObjectUtils.isEmpty(this.allowedHeaders)) {
        return null;
    } 
    boolean allowAnyHeader = this.allowedHeaders.contains(ALL);
    List<String> result = new ArrayList<>(requestHeaders.size());
    for (String requestHeader: requestHeaders) {
        if (StringUtils.hasText(requestHeader)) {
            requestHeader = requestHeader.trim();
            if (allowAnyHeader) {
                result.add(requestHeader);
            } else {
                for (String allowedHeader: this.allowedHeaders) {
                    if (requestHeader.equalsIgnoreCase(allowedHeader)) {
                        result.add(requestHeader);
                        break;
                    } 
                }
            }
        } 
    }
    return (result.isEmpty() ? null : result);
}
org.springframework.web.cors.CorsConfiguration

@Nullable public List<HttpMethod> checkHttpMethod(@Nullable HttpMethod requestMethod)

{
    if (requestMethod == null) {
        return null;
    } 
    if (this.resolvedMethods == null) {
        return Collections.singletonList(requestMethod);
    } 
    return (this.resolvedMethods.contains(requestMethod) ? this.resolvedMethods : null);
}
org.springframework.web.cors.CorsConfiguration

@Nullable public String checkOrigin(@Nullable String requestOrigin)

{
    if (!StringUtils.hasText(requestOrigin)) {
        return null;
    } 
    if (ObjectUtils.isEmpty(this.allowedOrigins)) {
        return null;
    } 
    if (this.allowedOrigins.contains(ALL)) {
        if (this.allowCredentials != Boolean.TRUE) {
            return ALL;
        } else {
            return requestOrigin;
        }
    } 
    for (String allowedOrigin: this.allowedOrigins) {
        if (requestOrigin.equalsIgnoreCase(allowedOrigin)) {
            return requestOrigin;
        } 
    }
    return null;
}
org.springframework.web.cors.CorsConfiguration

@Nullable public CorsConfiguration combine(@Nullable CorsConfiguration other)

{
    if (other == null) {
        return this;
    } 
    CorsConfiguration config = new CorsConfiguration(this);
    config.setAllowedOrigins(combine(getAllowedOrigins(), other.getAllowedOrigins()));
    config.setAllowedMethods(combine(getAllowedMethods(), other.getAllowedMethods()));
    config.setAllowedHeaders(combine(getAllowedHeaders(), other.getAllowedHeaders()));
    config.setExposedHeaders(combine(getExposedHeaders(), other.getExposedHeaders()));
    Boolean allowCredentials = other.getAllowCredentials();
    if (allowCredentials != null) {
        config.setAllowCredentials(allowCredentials);
    } 
    Long maxAge = other.getMaxAge();
    if (maxAge != null) {
        config.setMaxAge(maxAge);
    } 
    return config;
}
org.springframework.web.cors.CorsConfiguration

@Nullable public Boolean getAllowCredentials()

{
    return this.allowCredentials;
}
org.springframework.web.cors.CorsConfiguration

@Nullable public List<String> getAllowedHeaders()

{
    return this.allowedHeaders;
}
org.springframework.web.cors.CorsConfiguration

@Nullable public List<String> getAllowedMethods()

{
    return this.allowedMethods;
}
org.springframework.web.cors.CorsConfiguration

@Nullable public List<String> getAllowedOrigins()

{
    return this.allowedOrigins;
}
org.springframework.web.cors.CorsConfiguration

@Nullable public List<String> getExposedHeaders()

{
    return this.exposedHeaders;
}
org.springframework.web.cors.CorsConfiguration

@Nullable public Long getMaxAge()

{
    return this.maxAge;
}
org.springframework.web.cors.CorsConfiguration

public void setAllowCredentials(@Nullable Boolean allowCredentials)

{
    this.allowCredentials = allowCredentials;
}
org.springframework.web.cors.CorsConfiguration

public void setAllowedHeaders(@Nullable List<String> allowedHeaders)

{
    this.allowedHeaders = (allowedHeaders != null ? new ArrayList<>(allowedHeaders) : null);
}
org.springframework.web.cors.CorsConfiguration

public void setAllowedOrigins(@Nullable List<String> allowedOrigins)

{
    this.allowedOrigins = (allowedOrigins != null ? new ArrayList<>(allowedOrigins) : null);
}
org.springframework.web.cors.CorsConfiguration

public void setExposedHeaders(@Nullable List<String> exposedHeaders)

{
    if (exposedHeaders != null && exposedHeaders.contains(ALL)) {
        throw new IllegalArgumentException("'*' is not a valid exposed header value");
    } 
    this.exposedHeaders = (exposedHeaders != null ? new ArrayList<>(exposedHeaders) : null);
}
org.springframework.web.cors.CorsConfiguration

public void setMaxAge(Duration maxAge)

{
    this.maxAge = maxAge.getSeconds();
}
org.springframework.web.cors.CorsConfiguration

public void setMaxAge(@Nullable Long maxAge)

{
    this.maxAge = maxAge;
}

CorsConfigurationSource

CorsProcessor

CorsUtils

org.springframework.web.cors.CorsUtils

public static boolean isCorsRequest(HttpServletRequest request)

{
    String origin = request.getHeader(HttpHeaders.ORIGIN);
    if (origin == null) {
        return false;
    } 
    UriComponents originUrl = UriComponentsBuilder.fromOriginHeader(origin).build();
    String scheme = request.getScheme();
    String host = request.getServerName();
    int port = request.getServerPort();
    return !(ObjectUtils.nullSafeEquals(scheme, originUrl.getScheme()) && ObjectUtils.nullSafeEquals(host, originUrl.getHost()) && getPort(scheme, port) == getPort(originUrl.getScheme(), originUrl.getPort()));
}
org.springframework.web.cors.CorsUtils

public static boolean isPreFlightRequest(HttpServletRequest request)

{
    return (HttpMethod.OPTIONS.matches(request.getMethod()) && request.getHeader(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD) != null);
}

DefaultCorsProcessor
implements CorsProcessor

org.springframework.web.cors.DefaultCorsProcessor

@Nullable protected List<String> checkHeaders(CorsConfiguration config, List<String> requestHeaders)

{
    return config.checkHeaders(requestHeaders);
}
org.springframework.web.cors.DefaultCorsProcessor

@Nullable protected List<HttpMethod> checkMethods(CorsConfiguration config, @Nullable HttpMethod requestMethod)

{
    return config.checkHttpMethod(requestMethod);
}
org.springframework.web.cors.DefaultCorsProcessor

@Nullable protected String checkOrigin(CorsConfiguration config, @Nullable String requestOrigin)

{
    return config.checkOrigin(requestOrigin);
}
org.springframework.web.cors.DefaultCorsProcessor

protected boolean handleInternal(ServerHttpRequest request, ServerHttpResponse response, CorsConfiguration config, boolean preFlightRequest)

{
    String requestOrigin = request.getHeaders().getOrigin();
    String allowOrigin = checkOrigin(config, requestOrigin);
    HttpHeaders responseHeaders = response.getHeaders();
    if (allowOrigin == null) {
        logger.debug("Reject: '" + requestOrigin + "' origin is not allowed");
        rejectRequest(response);
        return false;
    } 
    HttpMethod requestMethod = getMethodToUse(request, preFlightRequest);
    List<HttpMethod> allowMethods = checkMethods(config, requestMethod);
    if (allowMethods == null) {
        logger.debug("Reject: HTTP '" + requestMethod + "' is not allowed");
        rejectRequest(response);
        return false;
    } 
    List<String> requestHeaders = getHeadersToUse(request, preFlightRequest);
    List<String> allowHeaders = checkHeaders(config, requestHeaders);
    if (preFlightRequest && allowHeaders == null) {
        logger.debug("Reject: headers '" + requestHeaders + "' are not allowed");
        rejectRequest(response);
        return false;
    } 
    responseHeaders.setAccessControlAllowOrigin(allowOrigin);
    if (preFlightRequest) {
        responseHeaders.setAccessControlAllowMethods(allowMethods);
    } 
    if (preFlightRequest && !allowHeaders.isEmpty()) {
        responseHeaders.setAccessControlAllowHeaders(allowHeaders);
    } 
    if (!CollectionUtils.isEmpty(config.getExposedHeaders())) {
        responseHeaders.setAccessControlExposeHeaders(config.getExposedHeaders());
    } 
    if (Boolean.TRUE.equals(config.getAllowCredentials())) {
        responseHeaders.setAccessControlAllowCredentials(true);
    } 
    if (preFlightRequest && config.getMaxAge() != null) {
        responseHeaders.setAccessControlMaxAge(config.getMaxAge());
    } 
    response.flush();
    return true;
}
org.springframework.web.cors.DefaultCorsProcessor

@Override @SuppressWarnings("resource") public boolean processRequest(@Nullable CorsConfiguration config, HttpServletRequest request, HttpServletResponse response)

{
    response.addHeader(HttpHeaders.VARY, HttpHeaders.ORIGIN);
    response.addHeader(HttpHeaders.VARY, HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD);
    response.addHeader(HttpHeaders.VARY, HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS);
    if (!CorsUtils.isCorsRequest(request)) {
        return true;
    } 
    if (response.getHeader(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN) != null) {
        logger.trace("Skip: response already contains \"Access-Control-Allow-Origin\"");
        return true;
    } 
    boolean preFlightRequest = CorsUtils.isPreFlightRequest(request);
    if (config == null) {
        if (preFlightRequest) {
            rejectRequest(new ServletServerHttpResponse(response));
            return false;
        } else {
            return true;
        }
    } 
    return handleInternal(new ServletServerHttpRequest(request), new ServletServerHttpResponse(response), config, preFlightRequest);
}
org.springframework.web.cors.DefaultCorsProcessor

protected void rejectRequest(ServerHttpResponse response)

{
    response.setStatusCode(HttpStatus.FORBIDDEN);
    response.getBody().write("Invalid CORS request".getBytes(StandardCharsets.UTF_8));
    response.flush();
}

UrlBasedCorsConfigurationSource
implements CorsConfigurationSource

org.springframework.web.cors.UrlBasedCorsConfigurationSource

public Map<String, CorsConfiguration> getCorsConfigurations()

{
    return Collections.unmodifiableMap(this.corsConfigurations);
}
org.springframework.web.cors.UrlBasedCorsConfigurationSource

public void registerCorsConfiguration(String path, CorsConfiguration config)

{
    this.corsConfigurations.put(path, config);
}
org.springframework.web.cors.UrlBasedCorsConfigurationSource

public void setAlwaysUseFullPath(boolean alwaysUseFullPath)

{
    this.urlPathHelper.setAlwaysUseFullPath(alwaysUseFullPath);
}
org.springframework.web.cors.UrlBasedCorsConfigurationSource

public void setCorsConfigurations(@Nullable Map<String, CorsConfiguration> corsConfigurations)

{
    this.corsConfigurations.clear();
    if (corsConfigurations != null) {
        this.corsConfigurations.putAll(corsConfigurations);
    } 
}
org.springframework.web.cors.UrlBasedCorsConfigurationSource

public void setLookupPathAttributeName(@Nullable String lookupPathAttributeName)

{
    this.lookupPathAttributeName = lookupPathAttributeName;
}
org.springframework.web.cors.UrlBasedCorsConfigurationSource

public void setPathMatcher(PathMatcher pathMatcher)

{
    Assert.notNull(pathMatcher, "PathMatcher must not be null");
    this.pathMatcher = pathMatcher;
}
org.springframework.web.cors.UrlBasedCorsConfigurationSource

public void setRemoveSemicolonContent(boolean removeSemicolonContent)

{
    this.urlPathHelper.setRemoveSemicolonContent(removeSemicolonContent);
}
org.springframework.web.cors.UrlBasedCorsConfigurationSource

public void setUrlDecode(boolean urlDecode)

{
    this.urlPathHelper.setUrlDecode(urlDecode);
}
org.springframework.web.cors.UrlBasedCorsConfigurationSource

public void setUrlPathHelper(UrlPathHelper urlPathHelper)

{
    Assert.notNull(urlPathHelper, "UrlPathHelper must not be null");
    this.urlPathHelper = urlPathHelper;
}


CorsConfigurationSource

CorsProcessor

CorsUtils

org.springframework.web.cors.reactive.CorsUtils

@SuppressWarnings("deprecation") public static boolean isCorsRequest(ServerHttpRequest request)

{
    return request.getHeaders().containsKey(HttpHeaders.ORIGIN) && !isSameOrigin(request);
}
org.springframework.web.cors.reactive.CorsUtils

public static boolean isPreFlightRequest(ServerHttpRequest request)

{
    return (request.getMethod() == HttpMethod.OPTIONS && request.getHeaders().containsKey(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD));
}
org.springframework.web.cors.reactive.CorsUtils

@Deprecated public static boolean isSameOrigin(ServerHttpRequest request)

{
    String origin = request.getHeaders().getOrigin();
    if (origin == null) {
        return true;
    } 
    URI uri = request.getURI();
    String actualScheme = uri.getScheme();
    String actualHost = uri.getHost();
    int actualPort = getPort(uri.getScheme(), uri.getPort());
    Assert.notNull(actualScheme, "Actual request scheme must not be null");
    Assert.notNull(actualHost, "Actual request host must not be null");
    Assert.isTrue(actualPort != -1, "Actual request port must not be undefined");
    UriComponents originUrl = UriComponentsBuilder.fromOriginHeader(origin).build();
    return (actualScheme.equals(originUrl.getScheme()) && actualHost.equals(originUrl.getHost()) && actualPort == getPort(originUrl.getScheme(), originUrl.getPort()));
}

CorsWebFilter
implements WebFilter

org.springframework.web.cors.reactive.CorsWebFilter

public CorsWebFilter CorsWebFilter(CorsConfigurationSource configSource)

{
    this(configSource, new DefaultCorsProcessor());
}
org.springframework.web.cors.reactive.CorsWebFilter

public CorsWebFilter CorsWebFilter(CorsConfigurationSource configSource, CorsProcessor processor)

{
    Assert.notNull(configSource, "CorsConfigurationSource must not be null");
    Assert.notNull(processor, "CorsProcessor must not be null");
    this.configSource = configSource;
    this.processor = processor;
}

DefaultCorsProcessor
implements CorsProcessor

org.springframework.web.cors.reactive.DefaultCorsProcessor

@Nullable protected List<String> checkHeaders(CorsConfiguration config, List<String> requestHeaders)

{
    return config.checkHeaders(requestHeaders);
}
org.springframework.web.cors.reactive.DefaultCorsProcessor

@Nullable protected List<HttpMethod> checkMethods(CorsConfiguration config, @Nullable HttpMethod requestMethod)

{
    return config.checkHttpMethod(requestMethod);
}
org.springframework.web.cors.reactive.DefaultCorsProcessor

@Nullable protected String checkOrigin(CorsConfiguration config, @Nullable String requestOrigin)

{
    return config.checkOrigin(requestOrigin);
}
org.springframework.web.cors.reactive.DefaultCorsProcessor

protected boolean handleInternal(ServerWebExchange exchange, CorsConfiguration config, boolean preFlightRequest)

{
    ServerHttpRequest request = exchange.getRequest();
    ServerHttpResponse response = exchange.getResponse();
    HttpHeaders responseHeaders = response.getHeaders();
    String requestOrigin = request.getHeaders().getOrigin();
    String allowOrigin = checkOrigin(config, requestOrigin);
    if (allowOrigin == null) {
        logger.debug("Reject: '" + requestOrigin + "' origin is not allowed");
        rejectRequest(response);
        return false;
    } 
    HttpMethod requestMethod = getMethodToUse(request, preFlightRequest);
    List<HttpMethod> allowMethods = checkMethods(config, requestMethod);
    if (allowMethods == null) {
        logger.debug("Reject: HTTP '" + requestMethod + "' is not allowed");
        rejectRequest(response);
        return false;
    } 
    List<String> requestHeaders = getHeadersToUse(request, preFlightRequest);
    List<String> allowHeaders = checkHeaders(config, requestHeaders);
    if (preFlightRequest && allowHeaders == null) {
        logger.debug("Reject: headers '" + requestHeaders + "' are not allowed");
        rejectRequest(response);
        return false;
    } 
    responseHeaders.setAccessControlAllowOrigin(allowOrigin);
    if (preFlightRequest) {
        responseHeaders.setAccessControlAllowMethods(allowMethods);
    } 
    if (preFlightRequest && !allowHeaders.isEmpty()) {
        responseHeaders.setAccessControlAllowHeaders(allowHeaders);
    } 
    if (!CollectionUtils.isEmpty(config.getExposedHeaders())) {
        responseHeaders.setAccessControlExposeHeaders(config.getExposedHeaders());
    } 
    if (Boolean.TRUE.equals(config.getAllowCredentials())) {
        responseHeaders.setAccessControlAllowCredentials(true);
    } 
    if (preFlightRequest && config.getMaxAge() != null) {
        responseHeaders.setAccessControlMaxAge(config.getMaxAge());
    } 
    return true;
}
org.springframework.web.cors.reactive.DefaultCorsProcessor

@Override public boolean process(@Nullable CorsConfiguration config, ServerWebExchange exchange)

{
    ServerHttpRequest request = exchange.getRequest();
    ServerHttpResponse response = exchange.getResponse();
    response.getHeaders().addAll(HttpHeaders.VARY, VARY_HEADERS);
    if (!CorsUtils.isCorsRequest(request)) {
        return true;
    } 
    if (response.getHeaders().getFirst(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN) != null) {
        logger.trace("Skip: response already contains \"Access-Control-Allow-Origin\"");
        return true;
    } 
    boolean preFlightRequest = CorsUtils.isPreFlightRequest(request);
    if (config == null) {
        if (preFlightRequest) {
            rejectRequest(response);
            return false;
        } else {
            return true;
        }
    } 
    return handleInternal(exchange, config, preFlightRequest);
}
org.springframework.web.cors.reactive.DefaultCorsProcessor

protected void rejectRequest(ServerHttpResponse response)

{
    response.setStatusCode(HttpStatus.FORBIDDEN);
}

UrlBasedCorsConfigurationSource
implements CorsConfigurationSource

org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource

public UrlBasedCorsConfigurationSource UrlBasedCorsConfigurationSource()

{
    this(new PathPatternParser());
}
org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource

public UrlBasedCorsConfigurationSource UrlBasedCorsConfigurationSource(PathPatternParser patternParser)

{
    this.corsConfigurations = new LinkedHashMap<>();
    this.patternParser = patternParser;
}
org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource

@Override @Nullable public CorsConfiguration getCorsConfiguration(ServerWebExchange exchange)

{
    PathContainer lookupPath = exchange.getRequest().getPath().pathWithinApplication();
    return this.corsConfigurations.entrySet().stream().filter(entry -> entry.getKey().matches(lookupPath)).map(Map.Entry::getValue).findFirst().orElse(null);
}
org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource

public void registerCorsConfiguration(String path, CorsConfiguration config)

{
    this.corsConfigurations.put(this.patternParser.parse(path), config);
}
org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource

public void setCorsConfigurations(@Nullable Map<String, CorsConfiguration> corsConfigurations)

{
    this.corsConfigurations.clear();
    if (corsConfigurations != null) {
        corsConfigurations.forEach(this::registerCorsConfiguration);
    } 
}


AbstractRequestLoggingFilter
extends OncePerRequestFilter

org.springframework.web.filter.AbstractRequestLoggingFilter

public static final String DEFAULT_AFTER_MESSAGE_PREFIX

org.springframework.web.filter.AbstractRequestLoggingFilter

public static final String DEFAULT_AFTER_MESSAGE_SUFFIX

org.springframework.web.filter.AbstractRequestLoggingFilter

public static final String DEFAULT_BEFORE_MESSAGE_PREFIX

org.springframework.web.filter.AbstractRequestLoggingFilter

public static final String DEFAULT_BEFORE_MESSAGE_SUFFIX

org.springframework.web.filter.AbstractRequestLoggingFilter

protected abstract void afterRequest(HttpServletRequest request, String message)

org.springframework.web.filter.AbstractRequestLoggingFilter

protected abstract void beforeRequest(HttpServletRequest request, String message)

org.springframework.web.filter.AbstractRequestLoggingFilter

@Nullable public Predicate<String> getHeaderPredicate()

{
    return this.headerPredicate;
}
org.springframework.web.filter.AbstractRequestLoggingFilter

protected int getMaxPayloadLength()

{
    return this.maxPayloadLength;
}
org.springframework.web.filter.AbstractRequestLoggingFilter

protected boolean isIncludeClientInfo()

{
    return this.includeClientInfo;
}
org.springframework.web.filter.AbstractRequestLoggingFilter

protected boolean isIncludeHeaders()

{
    return this.includeHeaders;
}
org.springframework.web.filter.AbstractRequestLoggingFilter

protected boolean isIncludePayload()

{
    return this.includePayload;
}
org.springframework.web.filter.AbstractRequestLoggingFilter

protected boolean isIncludeQueryString()

{
    return this.includeQueryString;
}
org.springframework.web.filter.AbstractRequestLoggingFilter

public void setAfterMessagePrefix(String afterMessagePrefix)

{
    this.afterMessagePrefix = afterMessagePrefix;
}
org.springframework.web.filter.AbstractRequestLoggingFilter

public void setAfterMessageSuffix(String afterMessageSuffix)

{
    this.afterMessageSuffix = afterMessageSuffix;
}
org.springframework.web.filter.AbstractRequestLoggingFilter

public void setBeforeMessagePrefix(String beforeMessagePrefix)

{
    this.beforeMessagePrefix = beforeMessagePrefix;
}
org.springframework.web.filter.AbstractRequestLoggingFilter

public void setBeforeMessageSuffix(String beforeMessageSuffix)

{
    this.beforeMessageSuffix = beforeMessageSuffix;
}
org.springframework.web.filter.AbstractRequestLoggingFilter

public void setHeaderPredicate(@Nullable Predicate<String> headerPredicate)

{
    this.headerPredicate = headerPredicate;
}
org.springframework.web.filter.AbstractRequestLoggingFilter

public void setIncludeClientInfo(boolean includeClientInfo)

{
    this.includeClientInfo = includeClientInfo;
}
org.springframework.web.filter.AbstractRequestLoggingFilter

public void setIncludeHeaders(boolean includeHeaders)

{
    this.includeHeaders = includeHeaders;
}
org.springframework.web.filter.AbstractRequestLoggingFilter

public void setIncludePayload(boolean includePayload)

{
    this.includePayload = includePayload;
}
org.springframework.web.filter.AbstractRequestLoggingFilter

public void setIncludeQueryString(boolean includeQueryString)

{
    this.includeQueryString = includeQueryString;
}
org.springframework.web.filter.AbstractRequestLoggingFilter

public void setMaxPayloadLength(int maxPayloadLength)

{
    Assert.isTrue(maxPayloadLength >= 0, "'maxPayloadLength' should be larger than or equal to 0");
    this.maxPayloadLength = maxPayloadLength;
}
org.springframework.web.filter.AbstractRequestLoggingFilter

protected boolean shouldLog(HttpServletRequest request)

{
    return true;
}
org.springframework.web.filter.AbstractRequestLoggingFilter

@Override protected boolean shouldNotFilterAsyncDispatch()

{
    return false;
}

CharacterEncodingFilter
extends OncePerRequestFilter

org.springframework.web.filter.CharacterEncodingFilter

public CharacterEncodingFilter CharacterEncodingFilter()

{
}
org.springframework.web.filter.CharacterEncodingFilter

public CharacterEncodingFilter CharacterEncodingFilter(String encoding)

{
    this(encoding, false);
}
org.springframework.web.filter.CharacterEncodingFilter

public CharacterEncodingFilter CharacterEncodingFilter(String encoding, boolean forceEncoding)

{
    this(encoding, forceEncoding, forceEncoding);
}
org.springframework.web.filter.CharacterEncodingFilter

public CharacterEncodingFilter CharacterEncodingFilter(String encoding, boolean forceRequestEncoding, boolean forceResponseEncoding)

{
    Assert.hasLength(encoding, "Encoding must not be empty");
    this.encoding = encoding;
    this.forceRequestEncoding = forceRequestEncoding;
    this.forceResponseEncoding = forceResponseEncoding;
}
org.springframework.web.filter.CharacterEncodingFilter

@Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)

{
    String encoding = getEncoding();
    if (encoding != null) {
        if (isForceRequestEncoding() || request.getCharacterEncoding() == null) {
            request.setCharacterEncoding(encoding);
        } 
        if (isForceResponseEncoding()) {
            response.setCharacterEncoding(encoding);
        } 
    } 
    filterChain.doFilter(request, response);
}
org.springframework.web.filter.CharacterEncodingFilter

@Nullable public String getEncoding()

{
    return this.encoding;
}
org.springframework.web.filter.CharacterEncodingFilter

public boolean isForceRequestEncoding()

{
    return this.forceRequestEncoding;
}
org.springframework.web.filter.CharacterEncodingFilter

public boolean isForceResponseEncoding()

{
    return this.forceResponseEncoding;
}
org.springframework.web.filter.CharacterEncodingFilter

public void setEncoding(@Nullable String encoding)

{
    this.encoding = encoding;
}
org.springframework.web.filter.CharacterEncodingFilter

public void setForceEncoding(boolean forceEncoding)

{
    this.forceRequestEncoding = forceEncoding;
    this.forceResponseEncoding = forceEncoding;
}
org.springframework.web.filter.CharacterEncodingFilter

public void setForceRequestEncoding(boolean forceRequestEncoding)

{
    this.forceRequestEncoding = forceRequestEncoding;
}
org.springframework.web.filter.CharacterEncodingFilter

public void setForceResponseEncoding(boolean forceResponseEncoding)

{
    this.forceResponseEncoding = forceResponseEncoding;
}

CommonsRequestLoggingFilter
extends AbstractRequestLoggingFilter

org.springframework.web.filter.CommonsRequestLoggingFilter

@Override protected void afterRequest(HttpServletRequest request, String message)

{
    logger.debug(message);
}
org.springframework.web.filter.CommonsRequestLoggingFilter

@Override protected void beforeRequest(HttpServletRequest request, String message)

{
    logger.debug(message);
}
org.springframework.web.filter.CommonsRequestLoggingFilter

@Override protected boolean shouldLog(HttpServletRequest request)

{
    return logger.isDebugEnabled();
}

CompositeFilter
implements Filter

org.springframework.web.filter.CompositeFilter

@Override public void destroy()

{
    for (int i = this.filters.size(); i-- > 0; ) {
        Filter filter = this.filters.get(i);
        filter.destroy();
    }
}
org.springframework.web.filter.CompositeFilter

@Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)

{
    new VirtualFilterChain(chain, this.filters).doFilter(request, response);
}
org.springframework.web.filter.CompositeFilter

@Override public void init(FilterConfig config)

{
    for (Filter filter: this.filters) {
        filter.init(config);
    }
}
org.springframework.web.filter.CompositeFilter

public void setFilters(List<?> filters)

{
    this.filters = new ArrayList<>(filters);
}

CorsFilter
extends OncePerRequestFilter

org.springframework.web.filter.CorsFilter

public CorsFilter CorsFilter(CorsConfigurationSource configSource)

{
    Assert.notNull(configSource, "CorsConfigurationSource must not be null");
    this.configSource = configSource;
}
org.springframework.web.filter.CorsFilter

@Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)

{
    CorsConfiguration corsConfiguration = this.configSource.getCorsConfiguration(request);
    boolean isValid = this.processor.processRequest(corsConfiguration, request, response);
    if (!isValid || CorsUtils.isPreFlightRequest(request)) {
        return ;
    } 
    filterChain.doFilter(request, response);
}
org.springframework.web.filter.CorsFilter

public void setCorsProcessor(CorsProcessor processor)

{
    Assert.notNull(processor, "CorsProcessor must not be null");
    this.processor = processor;
}

DelegatingFilterProxy
extends GenericFilterBean

org.springframework.web.filter.DelegatingFilterProxy

public DelegatingFilterProxy DelegatingFilterProxy()

{
}
org.springframework.web.filter.DelegatingFilterProxy

public DelegatingFilterProxy DelegatingFilterProxy(Filter delegate)

{
    Assert.notNull(delegate, "Delegate Filter must not be null");
    this.delegate = delegate;
}
org.springframework.web.filter.DelegatingFilterProxy

public DelegatingFilterProxy DelegatingFilterProxy(String targetBeanName)

{
    this(targetBeanName, null);
}
org.springframework.web.filter.DelegatingFilterProxy

public DelegatingFilterProxy DelegatingFilterProxy(String targetBeanName, @Nullable WebApplicationContext wac)

{
    Assert.hasText(targetBeanName, "Target Filter bean name must not be null or empty");
    this.setTargetBeanName(targetBeanName);
    this.webApplicationContext = wac;
    if (wac != null) {
        this.setEnvironment(wac.getEnvironment());
    } 
}
org.springframework.web.filter.DelegatingFilterProxy

@Nullable volatile Filter delegate

org.springframework.web.filter.DelegatingFilterProxy

@Override public void destroy()

{
    Filter delegateToUse = this.delegate;
    if (delegateToUse != null) {
        destroyDelegate(delegateToUse);
    } 
}
org.springframework.web.filter.DelegatingFilterProxy

protected void destroyDelegate(Filter delegate)

{
    if (isTargetFilterLifecycle()) {
        delegate.destroy();
    } 
}
org.springframework.web.filter.DelegatingFilterProxy

@Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)

{
    Filter delegateToUse = this.delegate;
    if (delegateToUse == null) {
        synchronized(this.delegateMonitor) {
            delegateToUse = this.delegate;
            if (delegateToUse == null) {
                WebApplicationContext wac = findWebApplicationContext();
                if (wac == null) {
                    throw new IllegalStateException("No WebApplicationContext found: " + "no ContextLoaderListener or DispatcherServlet registered?");
                } 
                delegateToUse = initDelegate(wac);
            } 
            this.delegate = delegateToUse;
        }
    } 
    invokeDelegate(delegateToUse, request, response, filterChain);
}
org.springframework.web.filter.DelegatingFilterProxy

@Nullable public String getContextAttribute()

{
    return this.contextAttribute;
}
org.springframework.web.filter.DelegatingFilterProxy

@Nullable protected String getTargetBeanName()

{
    return this.targetBeanName;
}
org.springframework.web.filter.DelegatingFilterProxy

@Override protected void initFilterBean()

{
    synchronized(this.delegateMonitor) {
        if (this.delegate == null) {
            if (this.targetBeanName == null) {
                this.targetBeanName = getFilterName();
            } 
            WebApplicationContext wac = findWebApplicationContext();
            if (wac != null) {
                this.delegate = initDelegate(wac);
            } 
        } 
    }
}
org.springframework.web.filter.DelegatingFilterProxy

protected void invokeDelegate(Filter delegate, ServletRequest request, ServletResponse response, FilterChain filterChain)

{
    delegate.doFilter(request, response, filterChain);
}
org.springframework.web.filter.DelegatingFilterProxy

protected boolean isTargetFilterLifecycle()

{
    return this.targetFilterLifecycle;
}
org.springframework.web.filter.DelegatingFilterProxy

public void setContextAttribute(@Nullable String contextAttribute)

{
    this.contextAttribute = contextAttribute;
}
org.springframework.web.filter.DelegatingFilterProxy

public void setTargetBeanName(@Nullable String targetBeanName)

{
    this.targetBeanName = targetBeanName;
}
org.springframework.web.filter.DelegatingFilterProxy

public void setTargetFilterLifecycle(boolean targetFilterLifecycle)

{
    this.targetFilterLifecycle = targetFilterLifecycle;
}

FormContentFilter
extends OncePerRequestFilter

org.springframework.web.filter.FormContentFilter

@Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)

{
    MultiValueMap<String, String> params = parseIfNecessary(request);
    if (!CollectionUtils.isEmpty(params)) {
        filterChain.doFilter(new FormContentRequestWrapper(request, params), response);
    } else {
        filterChain.doFilter(request, response);
    }
}
org.springframework.web.filter.FormContentFilter

public void setCharset(Charset charset)

{
    this.formConverter.setCharset(charset);
}
org.springframework.web.filter.FormContentFilter

public void setFormConverter(FormHttpMessageConverter converter)

{
    Assert.notNull(converter, "FormHttpMessageConverter is required");
    this.formConverter = converter;
}

ForwardedHeaderFilter
extends OncePerRequestFilter

org.springframework.web.filter.ForwardedHeaderFilter

public ForwardedHeaderFilter ForwardedHeaderFilter()

{
    this.pathHelper = new UrlPathHelper();
    this.pathHelper.setUrlDecode(false);
    this.pathHelper.setRemoveSemicolonContent(false);
}
org.springframework.web.filter.ForwardedHeaderFilter

@Override protected void doFilterNestedErrorDispatch(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)

{
    doFilterInternal(request, response, filterChain);
}
org.springframework.web.filter.ForwardedHeaderFilter

public void setRelativeRedirects(boolean relativeRedirects)

{
    this.relativeRedirects = relativeRedirects;
}
org.springframework.web.filter.ForwardedHeaderFilter

public void setRemoveOnly(boolean removeOnly)

{
    this.removeOnly = removeOnly;
}
org.springframework.web.filter.ForwardedHeaderFilter

@Override protected boolean shouldNotFilter(HttpServletRequest request)

{
    for (String headerName: FORWARDED_HEADER_NAMES) {
        if (request.getHeader(headerName) != null) {
            return false;
        } 
    }
    return true;
}
org.springframework.web.filter.ForwardedHeaderFilter

@Override protected boolean shouldNotFilterAsyncDispatch()

{
    return false;
}
org.springframework.web.filter.ForwardedHeaderFilter

@Override protected boolean shouldNotFilterErrorDispatch()

{
    return false;
}

GenericFilterBean
implements Filter, BeanNameAware, EnvironmentAware, EnvironmentCapable, ServletContextAware, InitializingBean, DisposableBean

org.springframework.web.filter.GenericFilterBean

protected final void addRequiredProperty(String property)

{
    this.requiredProperties.add(property);
}
org.springframework.web.filter.GenericFilterBean

@Override public void afterPropertiesSet()

{
    initFilterBean();
}
org.springframework.web.filter.GenericFilterBean

protected Environment createEnvironment()

{
    return new StandardServletEnvironment();
}
org.springframework.web.filter.GenericFilterBean

@Override public void destroy()

{
}
org.springframework.web.filter.GenericFilterBean

@Override public Environment getEnvironment()

{
    if (this.environment == null) {
        this.environment = createEnvironment();
    } 
    return this.environment;
}
org.springframework.web.filter.GenericFilterBean

@Nullable public FilterConfig getFilterConfig()

{
    return this.filterConfig;
}
org.springframework.web.filter.GenericFilterBean

@Nullable protected String getFilterName()

{
    return (this.filterConfig != null ? this.filterConfig.getFilterName() : this.beanName);
}
org.springframework.web.filter.GenericFilterBean

protected ServletContext getServletContext()

{
    if (this.filterConfig != null) {
        return this.filterConfig.getServletContext();
    } else if (this.servletContext != null) {
        return this.servletContext;
    } else {
        throw new IllegalStateException("No ServletContext");
    }
}
org.springframework.web.filter.GenericFilterBean

protected void initBeanWrapper(BeanWrapper bw)

{
}
org.springframework.web.filter.GenericFilterBean

protected void initFilterBean()

{
}
org.springframework.web.filter.GenericFilterBean

protected final Log logger

org.springframework.web.filter.GenericFilterBean

@Override public void setBeanName(String beanName)

{
    this.beanName = beanName;
}
org.springframework.web.filter.GenericFilterBean

@Override public void setEnvironment(Environment environment)

{
    this.environment = environment;
}
org.springframework.web.filter.GenericFilterBean

@Override public void setServletContext(ServletContext servletContext)

{
    this.servletContext = servletContext;
}

HiddenHttpMethodFilter
extends OncePerRequestFilter

org.springframework.web.filter.HiddenHttpMethodFilter

public static final String DEFAULT_METHOD_PARAM

org.springframework.web.filter.HiddenHttpMethodFilter

public void setMethodParam(String methodParam)

{
    Assert.hasText(methodParam, "'methodParam' must not be empty");
    this.methodParam = methodParam;
}

HttpPutFormContentFilter
extends OncePerRequestFilter

org.springframework.web.filter.HttpPutFormContentFilter

@Override protected void doFilterInternal(final HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)

{
    if (("PUT".equals(request.getMethod()) || "PATCH".equals(request.getMethod())) && isFormContentType(request)) {
        HttpInputMessage inputMessage = new ServletServerHttpRequest(request) {
            @Override
            public InputStream getBody() throws IOException{
                return request.getInputStream();
            }
        };
        MultiValueMap<String, String> formParameters = this.formConverter.read(null, inputMessage);
        if (!formParameters.isEmpty()) {
            HttpServletRequest wrapper = new HttpPutFormContentRequestWrapper(request, formParameters);
            filterChain.doFilter(wrapper, response);
            return ;
        } 
    } 
    filterChain.doFilter(request, response);
}
org.springframework.web.filter.HttpPutFormContentFilter

public FormHttpMessageConverter getFormConverter()

{
    return this.formConverter;
}
org.springframework.web.filter.HttpPutFormContentFilter

public void setCharset(Charset charset)

{
    this.formConverter.setCharset(charset);
}
org.springframework.web.filter.HttpPutFormContentFilter

public void setFormConverter(FormHttpMessageConverter converter)

{
    Assert.notNull(converter, "FormHttpMessageConverter is required.");
    this.formConverter = converter;
}

OncePerRequestFilter
extends GenericFilterBean

org.springframework.web.filter.OncePerRequestFilter

public static final String ALREADY_FILTERED_SUFFIX

org.springframework.web.filter.OncePerRequestFilter

@Override public final void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)

{
    if (!(request instanceof HttpServletRequest) || !(response instanceof HttpServletResponse)) {
        throw new ServletException("OncePerRequestFilter just supports HTTP requests");
    } 
    HttpServletRequest httpRequest = (HttpServletRequest)request;
    HttpServletResponse httpResponse = (HttpServletResponse)response;
    String alreadyFilteredAttributeName = getAlreadyFilteredAttributeName();
    boolean hasAlreadyFilteredAttribute = request.getAttribute(alreadyFilteredAttributeName) != null;
    if (skipDispatch(httpRequest) || shouldNotFilter(httpRequest)) {
        filterChain.doFilter(request, response);
    } else if (hasAlreadyFilteredAttribute) {
        if (DispatcherType.ERROR.equals(request.getDispatcherType())) {
            doFilterNestedErrorDispatch(httpRequest, httpResponse, filterChain);
            return ;
        } 
        filterChain.doFilter(request, response);
    } else {
        request.setAttribute(alreadyFilteredAttributeName, Boolean.TRUE);
        try {
            doFilterInternal(httpRequest, httpResponse, filterChain);
        } finally {
            request.removeAttribute(alreadyFilteredAttributeName);
        }
    }
}
org.springframework.web.filter.OncePerRequestFilter

protected abstract void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)

org.springframework.web.filter.OncePerRequestFilter

protected void doFilterNestedErrorDispatch(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)

{
    filterChain.doFilter(request, response);
}
org.springframework.web.filter.OncePerRequestFilter

protected String getAlreadyFilteredAttributeName()

{
    String name = getFilterName();
    if (name == null) {
        name = getClass().getName();
    } 
    return name + ALREADY_FILTERED_SUFFIX;
}
org.springframework.web.filter.OncePerRequestFilter

protected boolean isAsyncDispatch(HttpServletRequest request)

{
    return WebAsyncUtils.getAsyncManager(request).hasConcurrentResult();
}
org.springframework.web.filter.OncePerRequestFilter

protected boolean isAsyncStarted(HttpServletRequest request)

{
    return WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted();
}
org.springframework.web.filter.OncePerRequestFilter

protected boolean shouldNotFilter(HttpServletRequest request)

{
    return false;
}
org.springframework.web.filter.OncePerRequestFilter

protected boolean shouldNotFilterAsyncDispatch()

{
    return true;
}
org.springframework.web.filter.OncePerRequestFilter

protected boolean shouldNotFilterErrorDispatch()

{
    return true;
}

RelativeRedirectFilter
extends OncePerRequestFilter

org.springframework.web.filter.RelativeRedirectFilter

@Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)

{
    response = RelativeRedirectResponseWrapper.wrapIfNecessary(response, this.redirectStatus);
    filterChain.doFilter(request, response);
}
org.springframework.web.filter.RelativeRedirectFilter

public HttpStatus getRedirectStatus()

{
    return this.redirectStatus;
}

RelativeRedirectResponseWrapper
extends HttpServletResponseWrapper

org.springframework.web.filter.RelativeRedirectResponseWrapper

@Override public void sendRedirect(String location)

{
    setStatus(this.redirectStatus.value());
    setHeader(HttpHeaders.LOCATION, location);
}
org.springframework.web.filter.RelativeRedirectResponseWrapper

public static HttpServletResponse wrapIfNecessary(HttpServletResponse response, HttpStatus redirectStatus)

{
    RelativeRedirectResponseWrapper wrapper = WebUtils.getNativeResponse(response, RelativeRedirectResponseWrapper.class);
    return (wrapper != null ? response : new RelativeRedirectResponseWrapper(response, redirectStatus));
}

RequestContextFilter
extends OncePerRequestFilter

org.springframework.web.filter.RequestContextFilter

@Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)

{
    ServletRequestAttributes attributes = new ServletRequestAttributes(request, response);
    initContextHolders(request, attributes);
    try {
        filterChain.doFilter(request, response);
    } finally {
        resetContextHolders();
        if (logger.isTraceEnabled()) {
            logger.trace("Cleared thread-bound request context: " + request);
        } 
        attributes.requestCompleted();
    }
}
org.springframework.web.filter.RequestContextFilter

public void setThreadContextInheritable(boolean threadContextInheritable)

{
    this.threadContextInheritable = threadContextInheritable;
}
org.springframework.web.filter.RequestContextFilter

@Override protected boolean shouldNotFilterAsyncDispatch()

{
    return false;
}
org.springframework.web.filter.RequestContextFilter

@Override protected boolean shouldNotFilterErrorDispatch()

{
    return false;
}

ServletContextRequestLoggingFilter
extends AbstractRequestLoggingFilter

org.springframework.web.filter.ServletContextRequestLoggingFilter

@Override protected void afterRequest(HttpServletRequest request, String message)

{
    getServletContext().log(message);
}
org.springframework.web.filter.ServletContextRequestLoggingFilter

@Override protected void beforeRequest(HttpServletRequest request, String message)

{
    getServletContext().log(message);
}

ShallowEtagHeaderFilter
extends OncePerRequestFilter

org.springframework.web.filter.ShallowEtagHeaderFilter

public static void disableContentCaching(ServletRequest request)

{
    Assert.notNull(request, "ServletRequest must not be null");
    request.setAttribute(STREAMING_ATTRIBUTE, true);
}
org.springframework.web.filter.ShallowEtagHeaderFilter

@Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)

{
    HttpServletResponse responseToUse = response;
    if (!isAsyncDispatch(request) && !(response instanceof ContentCachingResponseWrapper)) {
        responseToUse = new HttpStreamingAwareContentCachingResponseWrapper(response, request);
    } 
    filterChain.doFilter(request, responseToUse);
    if (!isAsyncStarted(request) && !isContentCachingDisabled(request)) {
        updateResponse(request, responseToUse);
    } 
}
org.springframework.web.filter.ShallowEtagHeaderFilter

protected String generateETagHeaderValue(InputStream inputStream, boolean isWeak)

{
    StringBuilder builder = new StringBuilder(37);
    if (isWeak) {
        builder.append("W/");
    } 
    builder.append("\"0");
    DigestUtils.appendMd5DigestAsHex(inputStream, builder);
    builder.append('"');
    return builder.toString();
}
org.springframework.web.filter.ShallowEtagHeaderFilter

protected boolean isEligibleForEtag(HttpServletRequest request, HttpServletResponse response, int responseStatusCode, InputStream inputStream)

{
    String method = request.getMethod();
    if (responseStatusCode >= 200 && responseStatusCode < 300 && HttpMethod.GET.matches(method)) {
        String cacheControl = response.getHeader(HttpHeaders.CACHE_CONTROL);
        return (cacheControl == null || !cacheControl.contains(DIRECTIVE_NO_STORE));
    } 
    return false;
}
org.springframework.web.filter.ShallowEtagHeaderFilter

public boolean isWriteWeakETag()

{
    return this.writeWeakETag;
}
org.springframework.web.filter.ShallowEtagHeaderFilter

public void setWriteWeakETag(boolean writeWeakETag)

{
    this.writeWeakETag = writeWeakETag;
}
org.springframework.web.filter.ShallowEtagHeaderFilter

@Override protected boolean shouldNotFilterAsyncDispatch()

{
    return false;
}


ForwardedHeaderFilter
extends ForwardedHeaderTransformer implements WebFilter

org.springframework.web.filter.reactive.ForwardedHeaderFilter

@Override public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain)

{
    ServerHttpRequest request = exchange.getRequest();
    if (hasForwardedHeaders(request)) {
        exchange = exchange.mutate().request(apply(request)).build();
    } 
    return chain.filter(exchange);
}

HiddenHttpMethodFilter
implements WebFilter

org.springframework.web.filter.reactive.HiddenHttpMethodFilter

public static final String DEFAULT_METHOD_PARAMETER_NAME

org.springframework.web.filter.reactive.HiddenHttpMethodFilter

@Override public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain)

{
    if (exchange.getRequest().getMethod() != HttpMethod.POST) {
        return chain.filter(exchange);
    } 
    return exchange.getFormData().map(formData -> {
        String method = formData.getFirst(this.methodParamName);
        return StringUtils.hasLength(method) ? mapExchange(exchange, method) : exchange;
    }).flatMap(chain::filter);
}
org.springframework.web.filter.reactive.HiddenHttpMethodFilter

public void setMethodParamName(String methodParamName)

{
    Assert.hasText(methodParamName, "'methodParamName' must not be empty");
    this.methodParamName = methodParamName;
}

ServerWebExchangeContextFilter
implements WebFilter

org.springframework.web.filter.reactive.ServerWebExchangeContextFilter

public static final String EXCHANGE_CONTEXT_ATTRIBUTE

org.springframework.web.filter.reactive.ServerWebExchangeContextFilter

@Override public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain)

{
    return chain.filter(exchange).subscriberContext(cxt -> cxt.put(EXCHANGE_CONTEXT_ATTRIBUTE, exchange));
}
org.springframework.web.filter.reactive.ServerWebExchangeContextFilter

public static Optional<ServerWebExchange> get(Context context)

{
    return context.getOrEmpty(EXCHANGE_CONTEXT_ATTRIBUTE);
}


DecoratingNavigationHandler
extends NavigationHandler

org.springframework.web.jsf.DecoratingNavigationHandler

protected DecoratingNavigationHandler DecoratingNavigationHandler()

{
}
org.springframework.web.jsf.DecoratingNavigationHandler

protected DecoratingNavigationHandler DecoratingNavigationHandler(NavigationHandler originalNavigationHandler)

{
    this.decoratedNavigationHandler = originalNavigationHandler;
}
org.springframework.web.jsf.DecoratingNavigationHandler

@Nullable public final NavigationHandler getDecoratedNavigationHandler()

{
    return this.decoratedNavigationHandler;
}
org.springframework.web.jsf.DecoratingNavigationHandler

@Override public final void handleNavigation(FacesContext facesContext, String fromAction, String outcome)

{
    handleNavigation(facesContext, fromAction, outcome, this.decoratedNavigationHandler);
}
org.springframework.web.jsf.DecoratingNavigationHandler

public abstract void handleNavigation(FacesContext facesContext, @Nullable String fromAction, @Nullable String outcome, @Nullable NavigationHandler originalNavigationHandler)


DelegatingNavigationHandlerProxy
extends NavigationHandler

org.springframework.web.jsf.DelegatingNavigationHandlerProxy

public static final String DEFAULT_TARGET_BEAN_NAME

org.springframework.web.jsf.DelegatingNavigationHandlerProxy

public DelegatingNavigationHandlerProxy DelegatingNavigationHandlerProxy()

{
}
org.springframework.web.jsf.DelegatingNavigationHandlerProxy

public DelegatingNavigationHandlerProxy DelegatingNavigationHandlerProxy(NavigationHandler originalNavigationHandler)

{
    this.originalNavigationHandler = originalNavigationHandler;
}
org.springframework.web.jsf.DelegatingNavigationHandlerProxy

protected BeanFactory getBeanFactory(FacesContext facesContext)

{
    return getWebApplicationContext(facesContext);
}
org.springframework.web.jsf.DelegatingNavigationHandlerProxy

protected NavigationHandler getDelegate(FacesContext facesContext)

{
    String targetBeanName = getTargetBeanName(facesContext);
    return getBeanFactory(facesContext).getBean(targetBeanName, NavigationHandler.class);
}
org.springframework.web.jsf.DelegatingNavigationHandlerProxy

protected String getTargetBeanName(FacesContext facesContext)

{
    return DEFAULT_TARGET_BEAN_NAME;
}
org.springframework.web.jsf.DelegatingNavigationHandlerProxy

protected WebApplicationContext getWebApplicationContext(FacesContext facesContext)

{
    return FacesContextUtils.getRequiredWebApplicationContext(facesContext);
}

DelegatingPhaseListenerMulticaster
implements PhaseListener

org.springframework.web.jsf.DelegatingPhaseListenerMulticaster

@Override public void afterPhase(PhaseEvent event)

{
    for (PhaseListener listener: getDelegates(event.getFacesContext())) {
        listener.afterPhase(event);
    }
}
org.springframework.web.jsf.DelegatingPhaseListenerMulticaster

@Override public void beforePhase(PhaseEvent event)

{
    for (PhaseListener listener: getDelegates(event.getFacesContext())) {
        listener.beforePhase(event);
    }
}
org.springframework.web.jsf.DelegatingPhaseListenerMulticaster

protected ListableBeanFactory getBeanFactory(FacesContext facesContext)

{
    return getWebApplicationContext(facesContext);
}
org.springframework.web.jsf.DelegatingPhaseListenerMulticaster

protected Collection<PhaseListener> getDelegates(FacesContext facesContext)

{
    ListableBeanFactory bf = getBeanFactory(facesContext);
    return BeanFactoryUtils.beansOfTypeIncludingAncestors(bf, PhaseListener.class, true, false).values();
}
org.springframework.web.jsf.DelegatingPhaseListenerMulticaster

@Override public PhaseId getPhaseId()

{
    return PhaseId.ANY_PHASE;
}
org.springframework.web.jsf.DelegatingPhaseListenerMulticaster

protected WebApplicationContext getWebApplicationContext(FacesContext facesContext)

{
    return FacesContextUtils.getRequiredWebApplicationContext(facesContext);
}

FacesContextUtils

org.springframework.web.jsf.FacesContextUtils

public static WebApplicationContext getRequiredWebApplicationContext(FacesContext fc)

{
    WebApplicationContext wac = getWebApplicationContext(fc);
    if (wac == null) {
        throw new IllegalStateException("No WebApplicationContext found: no ContextLoaderListener registered?");
    } 
    return wac;
}
org.springframework.web.jsf.FacesContextUtils

@Nullable public static WebApplicationContext getWebApplicationContext(FacesContext fc)

{
    Assert.notNull(fc, "FacesContext must not be null");
    Object attr = fc.getExternalContext().getApplicationMap().get(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
    if (attr == null) {
        return null;
    } 
    if (attr instanceof RuntimeException) {
        throw (RuntimeException)attr;
    } 
    if (attr instanceof Error) {
        throw (Error)attr;
    } 
    if (!(attr instanceof WebApplicationContext)) {
        throw new IllegalStateException("Root context attribute is not of type WebApplicationContext: " + attr);
    } 
    return (WebApplicationContext)attr;
}

SpringBeanFacesELResolver
extends ELResolver

org.springframework.web.jsf.el.SpringBeanFacesELResolver

@Override public Class<?> getCommonPropertyType(ELContext elContext, @Nullable Object base)

{
    return Object.class;
}
org.springframework.web.jsf.el.SpringBeanFacesELResolver

@Override @Nullable public Iterator<FeatureDescriptor> getFeatureDescriptors(ELContext elContext, @Nullable Object base)

{
    return null;
}
org.springframework.web.jsf.el.SpringBeanFacesELResolver

@Override @Nullable public Class<?> getType(ELContext elContext, @Nullable Object base, Object property)

{
    if (base == null) {
        String beanName = property.toString();
        WebApplicationContext wac = getWebApplicationContext(elContext);
        if (wac.containsBean(beanName)) {
            elContext.setPropertyResolved(true);
            return wac.getType(beanName);
        } 
    } 
    return null;
}
org.springframework.web.jsf.el.SpringBeanFacesELResolver

@Override @Nullable public Object getValue(ELContext elContext, @Nullable Object base, Object property)

{
    if (base == null) {
        String beanName = property.toString();
        WebApplicationContext wac = getWebApplicationContext(elContext);
        if (wac.containsBean(beanName)) {
            elContext.setPropertyResolved(true);
            return wac.getBean(beanName);
        } 
    } 
    return null;
}
org.springframework.web.jsf.el.SpringBeanFacesELResolver

protected WebApplicationContext getWebApplicationContext(ELContext elContext)

{
    FacesContext facesContext = FacesContext.getCurrentInstance();
    return FacesContextUtils.getRequiredWebApplicationContext(facesContext);
}
org.springframework.web.jsf.el.SpringBeanFacesELResolver

@Override public boolean isReadOnly(ELContext elContext, @Nullable Object base, Object property)

{
    if (base == null) {
        String beanName = property.toString();
        WebApplicationContext wac = getWebApplicationContext(elContext);
        if (wac.containsBean(beanName)) {
            return true;
        } 
    } 
    return false;
}

WebApplicationContextFacesELResolver
extends ELResolver

org.springframework.web.jsf.el.WebApplicationContextFacesELResolver

public static final String WEB_APPLICATION_CONTEXT_VARIABLE_NAME

org.springframework.web.jsf.el.WebApplicationContextFacesELResolver

@Override public Class<?> getCommonPropertyType(ELContext elContext, Object base)

{
    return Object.class;
}
org.springframework.web.jsf.el.WebApplicationContextFacesELResolver

@Override @Nullable public Iterator<FeatureDescriptor> getFeatureDescriptors(ELContext elContext, Object base)

{
    return null;
}
org.springframework.web.jsf.el.WebApplicationContextFacesELResolver

@Nullable protected WebApplicationContext getWebApplicationContext(ELContext elContext)

{
    FacesContext facesContext = FacesContext.getCurrentInstance();
    return FacesContextUtils.getRequiredWebApplicationContext(facesContext);
}
org.springframework.web.jsf.el.WebApplicationContextFacesELResolver

@Override public boolean isReadOnly(ELContext elContext, Object base, Object property)

{
    if (base instanceof WebApplicationContext) {
        elContext.setPropertyResolved(true);
        return true;
    } 
    return false;
}
org.springframework.web.jsf.el.WebApplicationContextFacesELResolver

protected final Log logger

org.springframework.web.jsf.el.WebApplicationContextFacesELResolver

@Override public void setValue(ELContext elContext, Object base, Object property, Object value)

{
}



ControllerAdviceBean
implements Ordered

org.springframework.web.method.ControllerAdviceBean

public ControllerAdviceBean ControllerAdviceBean(String beanName, BeanFactory beanFactory)

{
    this(beanName, beanFactory, null);
}
org.springframework.web.method.ControllerAdviceBean

@Override public boolean equals(@Nullable Object other)

{
    if (this == other) {
        return true;
    } 
    if (!(other instanceof ControllerAdviceBean)) {
        return false;
    } 
    ControllerAdviceBean otherAdvice = (ControllerAdviceBean)other;
    return (this.beanOrName.equals(otherAdvice.beanOrName) && this.beanFactory == otherAdvice.beanFactory);
}
org.springframework.web.method.ControllerAdviceBean

@Nullable public Class<?> getBeanType()

{
    return this.beanType;
}
org.springframework.web.method.ControllerAdviceBean

@Override public int hashCode()

{
    return this.beanOrName.hashCode();
}
org.springframework.web.method.ControllerAdviceBean

public boolean isApplicableToBeanType(@Nullable Class<?> beanType)

{
    return this.beanTypePredicate.test(beanType);
}
org.springframework.web.method.ControllerAdviceBean

public Object resolveBean()

{
    if (this.resolvedBean == null) {
        this.resolvedBean = obtainBeanFactory().getBean((String)this.beanOrName);
    } 
    return this.resolvedBean;
}
org.springframework.web.method.ControllerAdviceBean

@Override public String toString()

{
    return this.beanOrName.toString();
}

HandlerMethod

org.springframework.web.method.HandlerMethod

public HandlerMethod HandlerMethod(String beanName, BeanFactory beanFactory, Method method)

{
    Assert.hasText(beanName, "Bean name is required");
    Assert.notNull(beanFactory, "BeanFactory is required");
    Assert.notNull(method, "Method is required");
    this.bean = beanName;
    this.beanFactory = beanFactory;
    Class<?> beanType = beanFactory.getType(beanName);
    if (beanType == null) {
        throw new IllegalStateException("Cannot resolve bean type for bean with name '" + beanName + "'");
    } 
    this.beanType = ClassUtils.getUserClass(beanType);
    this.method = method;
    this.bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
    this.parameters = initMethodParameters();
    evaluateResponseStatus();
    this.description = initDescription(this.beanType, this.method);
}
HandlerMethodParameter
extends SynthesizingMethodParameter

org.springframework.web.method.HandlerMethod.HandlerMethodParameter

public HandlerMethodParameter HandlerMethodParameter(int index)

{
    super(HandlerMethod.this.bridgedMethod, index);
}
org.springframework.web.method.HandlerMethod.HandlerMethodParameter

protected HandlerMethodParameter HandlerMethodParameter(HandlerMethodParameter original)

{
    super(original);
}
org.springframework.web.method.HandlerMethod.HandlerMethodParameter

@Override public HandlerMethodParameter clone()

{
    return new HandlerMethodParameter(this);
}
org.springframework.web.method.HandlerMethod.HandlerMethodParameter

@Nullable volatile Annotation[] combinedAnnotations

org.springframework.web.method.HandlerMethod.HandlerMethodParameter

@Override public Class<?> getContainingClass()

{
    return HandlerMethod.this.getBeanType();
}
org.springframework.web.method.HandlerMethod.HandlerMethodParameter

<T>@Override public T getMethodAnnotation(Class<T> annotationType)

{
    return HandlerMethod.this.getMethodAnnotation(annotationType);
}
org.springframework.web.method.HandlerMethod.HandlerMethodParameter

<T>@Override public boolean hasMethodAnnotation(Class<T> annotationType)

{
    return HandlerMethod.this.hasMethodAnnotation(annotationType);
}
org.springframework.web.method.HandlerMethod

@Override public boolean equals(@Nullable Object other)

{
    if (this == other) {
        return true;
    } 
    if (!(other instanceof HandlerMethod)) {
        return false;
    } 
    HandlerMethod otherMethod = (HandlerMethod)other;
    return (this.bean.equals(otherMethod.bean) && this.method.equals(otherMethod.method));
}
org.springframework.web.method.HandlerMethod

@Nullable protected static Object findProvidedArgument(MethodParameter parameter, @Nullable Object... providedArgs)

{
    if (!ObjectUtils.isEmpty(providedArgs)) {
        for (Object providedArg: providedArgs) {
            if (parameter.getParameterType().isInstance(providedArg)) {
                return providedArg;
            } 
        }
    } 
    return null;
}
org.springframework.web.method.HandlerMethod

protected static String formatArgumentError(MethodParameter param, String message)

{
    return "Could not resolve parameter [" + param.getParameterIndex() + "] in " + param.getExecutable().toGenericString() + (StringUtils.hasText(message) ? ": " + message : "");
}
org.springframework.web.method.HandlerMethod

public Object getBean()

{
    return this.bean;
}
org.springframework.web.method.HandlerMethod

public Class<?> getBeanType()

{
    return this.beanType;
}
org.springframework.web.method.HandlerMethod

protected Method getBridgedMethod()

{
    return this.bridgedMethod;
}
org.springframework.web.method.HandlerMethod

public Method getMethod()

{
    return this.method;
}
org.springframework.web.method.HandlerMethod

<A>@Nullable public A getMethodAnnotation(Class<A> annotationType)

{
    return AnnotatedElementUtils.findMergedAnnotation(this.method, annotationType);
}
org.springframework.web.method.HandlerMethod

public MethodParameter[] getMethodParameters()

{
    return this.parameters;
}
org.springframework.web.method.HandlerMethod

@Nullable public HandlerMethod getResolvedFromHandlerMethod()

{
    return this.resolvedFromHandlerMethod;
}
org.springframework.web.method.HandlerMethod

@Nullable protected HttpStatus getResponseStatus()

{
    return this.responseStatus;
}
org.springframework.web.method.HandlerMethod

@Nullable protected String getResponseStatusReason()

{
    return this.responseStatusReason;
}
org.springframework.web.method.HandlerMethod

public MethodParameter getReturnType()

{
    return new HandlerMethodParameter(-1);
}
org.springframework.web.method.HandlerMethod

public MethodParameter getReturnValueType(@Nullable Object returnValue)

{
    return new ReturnValueMethodParameter(returnValue);
}
org.springframework.web.method.HandlerMethod

public String getShortLogMessage()

{
    return getBeanType().getName() + "#" + this.method.getName() + "[" + this.method.getParameterCount() + " args]";
}
org.springframework.web.method.HandlerMethod

<A>public boolean hasMethodAnnotation(Class<A> annotationType)

{
    return AnnotatedElementUtils.hasAnnotation(this.method, annotationType);
}
org.springframework.web.method.HandlerMethod

@Override public int hashCode()

{
    return (this.bean.hashCode() * 31 + this.method.hashCode());
}
org.springframework.web.method.HandlerMethod

@Nullable volatile List<Annotation[]> interfaceParameterAnnotations

org.springframework.web.method.HandlerMethod

public boolean isVoid()

{
    return Void.TYPE.equals(getReturnType().getParameterType());
}
org.springframework.web.method.HandlerMethod

protected final Log logger

org.springframework.web.method.HandlerMethod

@Override public String toString()

{
    return this.description;
}

HandlerTypePredicate
implements Predicate<Class<?>>

Builder

org.springframework.web.method.HandlerTypePredicate.Builder

@SuppressWarnings("unchecked") public final Builder annotation(Class<?>... annotations)

{
    this.annotations.addAll(Arrays.asList(annotations));
    return this;
}
org.springframework.web.method.HandlerTypePredicate.Builder

public Builder assignableType(Class<?>... types)

{
    this.assignableTypes.addAll(Arrays.asList(types));
    return this;
}
org.springframework.web.method.HandlerTypePredicate.Builder

public Builder basePackage(String... packages)

{
    Arrays.stream(packages).filter(StringUtils::hasText).forEach(this::addBasePackage);
    return this;
}
org.springframework.web.method.HandlerTypePredicate.Builder

public Builder basePackageClass(Class<?>... packageClasses)

{
    Arrays.stream(packageClasses).forEach(clazz -> addBasePackage(ClassUtils.getPackageName(clazz)));
    return this;
}
org.springframework.web.method.HandlerTypePredicate.Builder

public HandlerTypePredicate build()

{
    return new HandlerTypePredicate(this.basePackages, this.assignableTypes, this.annotations);
}
org.springframework.web.method.HandlerTypePredicate

public static Builder builder()

{
    return new Builder();
}
org.springframework.web.method.HandlerTypePredicate

@SafeVarargs public static HandlerTypePredicate forAnnotation(Class<?>... annotations)

{
    return new Builder().annotation(annotations).build();
}
org.springframework.web.method.HandlerTypePredicate

public static HandlerTypePredicate forAnyHandlerType()

{
    return new HandlerTypePredicate(Collections.emptySet(), Collections.emptyList(), Collections.emptyList());
}
org.springframework.web.method.HandlerTypePredicate

public static HandlerTypePredicate forAssignableType(Class<?>... types)

{
    return new Builder().assignableType(types).build();
}
org.springframework.web.method.HandlerTypePredicate

public static HandlerTypePredicate forBasePackage(String... packages)

{
    return new Builder().basePackage(packages).build();
}
org.springframework.web.method.HandlerTypePredicate

public static HandlerTypePredicate forBasePackageClass(Class<?>... packageClasses)

{
    return new Builder().basePackageClass(packageClasses).build();
}
org.springframework.web.method.HandlerTypePredicate

@Override public boolean test(Class<?> controllerType)

{
    if (!hasSelectors()) {
        return true;
    } else if (controllerType != null) {
        for (String basePackage: this.basePackages) {
            if (controllerType.getName().startsWith(basePackage)) {
                return true;
            } 
        }
        for (Class<?> clazz: this.assignableTypes) {
            if (ClassUtils.isAssignable(clazz, controllerType)) {
                return true;
            } 
        }
        for (Class<? extends Annotation> annotationClass: this.annotations) {
            if (AnnotationUtils.findAnnotation(controllerType, annotationClass) != null) {
                return true;
            } 
        }
    } 
    return false;
}

AbstractCookieValueMethodArgumentResolver
extends AbstractNamedValueMethodArgumentResolver

org.springframework.web.method.annotation.AbstractCookieValueMethodArgumentResolver

public AbstractCookieValueMethodArgumentResolver AbstractCookieValueMethodArgumentResolver(@Nullable ConfigurableBeanFactory beanFactory)

{
    super(beanFactory);
}
org.springframework.web.method.annotation.AbstractCookieValueMethodArgumentResolver

@Override protected NamedValueInfo createNamedValueInfo(MethodParameter parameter)

{
    CookieValue annotation = parameter.getParameterAnnotation(CookieValue.class);
    Assert.state(annotation != null, "No CookieValue annotation");
    return new CookieValueNamedValueInfo(annotation);
}
org.springframework.web.method.annotation.AbstractCookieValueMethodArgumentResolver

@Override protected void handleMissingValue(String name, MethodParameter parameter)

{
    throw new MissingRequestCookieException(name, parameter);
}
org.springframework.web.method.annotation.AbstractCookieValueMethodArgumentResolver

@Override public boolean supportsParameter(MethodParameter parameter)

{
    return parameter.hasParameterAnnotation(CookieValue.class);
}

AbstractNamedValueMethodArgumentResolver
implements HandlerMethodArgumentResolver

org.springframework.web.method.annotation.AbstractNamedValueMethodArgumentResolver

public AbstractNamedValueMethodArgumentResolver AbstractNamedValueMethodArgumentResolver()

{
    this.configurableBeanFactory = null;
    this.expressionContext = null;
}
org.springframework.web.method.annotation.AbstractNamedValueMethodArgumentResolver

public AbstractNamedValueMethodArgumentResolver AbstractNamedValueMethodArgumentResolver(@Nullable ConfigurableBeanFactory beanFactory)

{
    this.configurableBeanFactory = beanFactory;
    this.expressionContext = (beanFactory != null ? new BeanExpressionContext(beanFactory, new RequestScope()) : null);
}
NamedValueInfo

org.springframework.web.method.annotation.AbstractNamedValueMethodArgumentResolver.NamedValueInfo

public NamedValueInfo NamedValueInfo(String name, boolean required, @Nullable String defaultValue)

{
    this.name = name;
    this.required = required;
    this.defaultValue = defaultValue;
}
org.springframework.web.method.annotation.AbstractNamedValueMethodArgumentResolver

protected abstract NamedValueInfo createNamedValueInfo(MethodParameter parameter)

org.springframework.web.method.annotation.AbstractNamedValueMethodArgumentResolver

protected void handleMissingValue(String name, MethodParameter parameter, NativeWebRequest request)

{
    handleMissingValue(name, parameter);
}
org.springframework.web.method.annotation.AbstractNamedValueMethodArgumentResolver

protected void handleMissingValue(String name, MethodParameter parameter)

{
    throw new ServletRequestBindingException("Missing argument '" + name + "' for method parameter of type " + parameter.getNestedParameterType().getSimpleName());
}
org.springframework.web.method.annotation.AbstractNamedValueMethodArgumentResolver

protected void handleResolvedValue(@Nullable Object arg, String name, MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest)

{
}
org.springframework.web.method.annotation.AbstractNamedValueMethodArgumentResolver

@Override @Nullable public final Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory)

{
    NamedValueInfo namedValueInfo = getNamedValueInfo(parameter);
    MethodParameter nestedParameter = parameter.nestedIfOptional();
    Object resolvedName = resolveStringValue(namedValueInfo.name);
    if (resolvedName == null) {
        throw new IllegalArgumentException("Specified name must not resolve to null: [" + namedValueInfo.name + "]");
    } 
    Object arg = resolveName(resolvedName.toString(), nestedParameter, webRequest);
    if (arg == null) {
        if (namedValueInfo.defaultValue != null) {
            arg = resolveStringValue(namedValueInfo.defaultValue);
        } else if (namedValueInfo.required && !nestedParameter.isOptional()) {
            handleMissingValue(namedValueInfo.name, nestedParameter, webRequest);
        } 
        arg = handleNullValue(namedValueInfo.name, arg, nestedParameter.getNestedParameterType());
    } else if ("".equals(arg) && namedValueInfo.defaultValue != null) {
        arg = resolveStringValue(namedValueInfo.defaultValue);
    } 
    if (binderFactory != null) {
        WebDataBinder binder = binderFactory.createBinder(webRequest, null, namedValueInfo.name);
        try {
            arg = binder.convertIfNecessary(arg, parameter.getParameterType(), parameter);
        } catch (ConversionNotSupportedException ex) {
            throw new MethodArgumentConversionNotSupportedException(arg, ex.getRequiredType(), namedValueInfo.name, parameter, ex.getCause());
        } catch (TypeMismatchException ex) {
            throw new MethodArgumentTypeMismatchException(arg, ex.getRequiredType(), namedValueInfo.name, parameter, ex.getCause());
        }
    } 
    handleResolvedValue(arg, namedValueInfo.name, parameter, mavContainer, webRequest);
    return arg;
}
org.springframework.web.method.annotation.AbstractNamedValueMethodArgumentResolver

@Nullable protected abstract Object resolveName(String name, MethodParameter parameter, NativeWebRequest request)


AbstractWebArgumentResolverAdapter
implements HandlerMethodArgumentResolver

org.springframework.web.method.annotation.AbstractWebArgumentResolverAdapter

public AbstractWebArgumentResolverAdapter AbstractWebArgumentResolverAdapter(WebArgumentResolver adaptee)

{
    Assert.notNull(adaptee, "'adaptee' must not be null");
    this.adaptee = adaptee;
}
org.springframework.web.method.annotation.AbstractWebArgumentResolverAdapter

protected abstract NativeWebRequest getWebRequest()


ErrorsMethodArgumentResolver
implements HandlerMethodArgumentResolver

org.springframework.web.method.annotation.ErrorsMethodArgumentResolver

@Override @Nullable public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory)

{
    Assert.state(mavContainer != null, "Errors/BindingResult argument only supported on regular handler methods");
    ModelMap model = mavContainer.getModel();
    String lastKey = CollectionUtils.lastElement(model.keySet());
    if (lastKey != null && lastKey.startsWith(BindingResult.MODEL_KEY_PREFIX)) {
        return model.get(lastKey);
    } 
    throw new IllegalStateException("An Errors/BindingResult argument is expected to be declared immediately after " + "the model attribute, the @RequestBody or the @RequestPart arguments " + "to which they apply: " + parameter.getMethod());
}
org.springframework.web.method.annotation.ErrorsMethodArgumentResolver

@Override public boolean supportsParameter(MethodParameter parameter)

{
    Class<?> paramType = parameter.getParameterType();
    return Errors.class.isAssignableFrom(paramType);
}

ExceptionHandlerMethodResolver

org.springframework.web.method.annotation.ExceptionHandlerMethodResolver

public static final MethodFilter EXCEPTION_HANDLER_METHODS

org.springframework.web.method.annotation.ExceptionHandlerMethodResolver

public ExceptionHandlerMethodResolver ExceptionHandlerMethodResolver(Class<?> handlerType)

{
    for (Method method: MethodIntrospector.selectMethods(handlerType, EXCEPTION_HANDLER_METHODS)) {
        for (Class<? extends Throwable> exceptionType: detectExceptionMappings(method)) {
            addExceptionMapping(exceptionType, method);
        }
    }
}
org.springframework.web.method.annotation.ExceptionHandlerMethodResolver

public boolean hasExceptionMappings()

{
    return !this.mappedMethods.isEmpty();
}
org.springframework.web.method.annotation.ExceptionHandlerMethodResolver

@Nullable public Method resolveMethod(Exception exception)

{
    return resolveMethodByThrowable(exception);
}
org.springframework.web.method.annotation.ExceptionHandlerMethodResolver

@Nullable public Method resolveMethodByExceptionType(Class<?> exceptionType)

{
    Method method = this.exceptionLookupCache.get(exceptionType);
    if (method == null) {
        method = getMappedMethod(exceptionType);
        this.exceptionLookupCache.put(exceptionType, method);
    } 
    return method;
}
org.springframework.web.method.annotation.ExceptionHandlerMethodResolver

@Nullable public Method resolveMethodByThrowable(Throwable exception)

{
    Method method = resolveMethodByExceptionType(exception.getClass());
    if (method == null) {
        Throwable cause = exception.getCause();
        if (cause != null) {
            method = resolveMethodByExceptionType(cause.getClass());
        } 
    } 
    return method;
}

ExpressionValueMethodArgumentResolver
extends AbstractNamedValueMethodArgumentResolver

org.springframework.web.method.annotation.ExpressionValueMethodArgumentResolver

public ExpressionValueMethodArgumentResolver ExpressionValueMethodArgumentResolver(@Nullable ConfigurableBeanFactory beanFactory)

{
    super(beanFactory);
}
org.springframework.web.method.annotation.ExpressionValueMethodArgumentResolver

@Override protected NamedValueInfo createNamedValueInfo(MethodParameter parameter)

{
    Value ann = parameter.getParameterAnnotation(Value.class);
    Assert.state(ann != null, "No Value annotation");
    return new ExpressionValueNamedValueInfo(ann);
}
org.springframework.web.method.annotation.ExpressionValueMethodArgumentResolver

@Override protected void handleMissingValue(String name, MethodParameter parameter)

{
    throw new UnsupportedOperationException("@Value is never required: " + parameter.getMethod());
}
org.springframework.web.method.annotation.ExpressionValueMethodArgumentResolver

@Override @Nullable protected Object resolveName(String name, MethodParameter parameter, NativeWebRequest webRequest)

{
    return null;
}
org.springframework.web.method.annotation.ExpressionValueMethodArgumentResolver

@Override public boolean supportsParameter(MethodParameter parameter)

{
    return parameter.hasParameterAnnotation(Value.class);
}

InitBinderDataBinderFactory
extends DefaultDataBinderFactory

org.springframework.web.method.annotation.InitBinderDataBinderFactory

public InitBinderDataBinderFactory InitBinderDataBinderFactory(@Nullable List<InvocableHandlerMethod> binderMethods, @Nullable WebBindingInitializer initializer)

{
    super(initializer);
    this.binderMethods = (binderMethods != null ? binderMethods : Collections.emptyList());
}

MapMethodProcessor
implements HandlerMethodArgumentResolver, HandlerMethodReturnValueHandler

org.springframework.web.method.annotation.MapMethodProcessor

@Override @SuppressWarnings({"rawtypes","unchecked"}) public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest)

{
    if (returnValue instanceof Map) {
        mavContainer.addAllAttributes((Map)returnValue);
    } else if (returnValue != null) {
        throw new UnsupportedOperationException("Unexpected return type: " + returnType.getParameterType().getName() + " in method: " + returnType.getMethod());
    } 
}
org.springframework.web.method.annotation.MapMethodProcessor

@Override @Nullable public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory)

{
    Assert.state(mavContainer != null, "ModelAndViewContainer is required for model exposure");
    return mavContainer.getModel();
}
org.springframework.web.method.annotation.MapMethodProcessor

@Override public boolean supportsParameter(MethodParameter parameter)

{
    return Map.class.isAssignableFrom(parameter.getParameterType()) && parameter.getParameterAnnotations().length == 0;
}
org.springframework.web.method.annotation.MapMethodProcessor

@Override public boolean supportsReturnType(MethodParameter returnType)

{
    return Map.class.isAssignableFrom(returnType.getParameterType());
}

MethodArgumentConversionNotSupportedException
extends ConversionNotSupportedException

org.springframework.web.method.annotation.MethodArgumentConversionNotSupportedException

public MethodArgumentConversionNotSupportedException MethodArgumentConversionNotSupportedException(@Nullable Object value, @Nullable Class<?> requiredType, String name, MethodParameter param, Throwable cause)

{
    super(value, requiredType, cause);
    this.name = name;
    this.parameter = param;
}
org.springframework.web.method.annotation.MethodArgumentConversionNotSupportedException

public String getName()

{
    return this.name;
}
org.springframework.web.method.annotation.MethodArgumentConversionNotSupportedException

public MethodParameter getParameter()

{
    return this.parameter;
}

MethodArgumentTypeMismatchException
extends TypeMismatchException

org.springframework.web.method.annotation.MethodArgumentTypeMismatchException

public MethodArgumentTypeMismatchException MethodArgumentTypeMismatchException(@Nullable Object value, @Nullable Class<?> requiredType, String name, MethodParameter param, Throwable cause)

{
    super(value, requiredType, cause);
    this.name = name;
    this.parameter = param;
}
org.springframework.web.method.annotation.MethodArgumentTypeMismatchException

public String getName()

{
    return this.name;
}
org.springframework.web.method.annotation.MethodArgumentTypeMismatchException

public MethodParameter getParameter()

{
    return this.parameter;
}

ModelAttributeMethodProcessor
implements HandlerMethodArgumentResolver, HandlerMethodReturnValueHandler

org.springframework.web.method.annotation.ModelAttributeMethodProcessor

public ModelAttributeMethodProcessor ModelAttributeMethodProcessor(boolean annotationNotRequired)

{
    this.annotationNotRequired = annotationNotRequired;
}
org.springframework.web.method.annotation.ModelAttributeMethodProcessor

protected void bindRequestParameters(WebDataBinder binder, NativeWebRequest request)

{
    ((WebRequestDataBinder)binder).bind(request);
}
org.springframework.web.method.annotation.ModelAttributeMethodProcessor

@SuppressWarnings("deprecation") protected Object constructAttribute(Constructor<?> ctor, String attributeName, MethodParameter parameter, WebDataBinderFactory binderFactory, NativeWebRequest webRequest)

{
    Object constructed = constructAttribute(ctor, attributeName, binderFactory, webRequest);
    if (constructed != null) {
        return constructed;
    } 
    if (ctor.getParameterCount() == 0) {
        return BeanUtils.instantiateClass(ctor);
    } 
    ConstructorProperties cp = ctor.getAnnotation(ConstructorProperties.class);
    String[] paramNames = (cp != null ? cp.value() : parameterNameDiscoverer.getParameterNames(ctor));
    Assert.state(paramNames != null, () -> "Cannot resolve parameter names for constructor " + ctor);
    Class<?>[] paramTypes = ctor.getParameterTypes();
    Assert.state(paramNames.length == paramTypes.length, () -> "Invalid number of parameter names: " + paramNames.length + " for constructor " + ctor);
    Object[] args = new Object[paramTypes.length];
    WebDataBinder binder = binderFactory.createBinder(webRequest, null, attributeName);
    String fieldDefaultPrefix = binder.getFieldDefaultPrefix();
    String fieldMarkerPrefix = binder.getFieldMarkerPrefix();
    boolean bindingFailure = false;
    Set<String> failedParams = new HashSet<>(4);
    for (int i = 0; i < paramNames.length; i++) {
        String paramName = paramNames[i];
        Class<?> paramType = paramTypes[i];
        Object value = webRequest.getParameterValues(paramName);
        if (value == null) {
            if (fieldDefaultPrefix != null) {
                value = webRequest.getParameter(fieldDefaultPrefix + paramName);
            } 
            if (value == null && fieldMarkerPrefix != null) {
                if (webRequest.getParameter(fieldMarkerPrefix + paramName) != null) {
                    value = binder.getEmptyValue(paramType);
                } 
            } 
        } 
        try {
            MethodParameter methodParam = new FieldAwareConstructorParameter(ctor, i, paramName);
            if (value == null && methodParam.isOptional()) {
                args[i] = (methodParam.getParameterType() == Optional.class ? Optional.empty() : null);
            } else {
                args[i] = binder.convertIfNecessary(value, paramType, methodParam);
            }
        } catch (TypeMismatchException ex) {
            ex.initPropertyName(paramName);
            args[i] = value;
            failedParams.add(paramName);
            binder.getBindingResult().recordFieldValue(paramName, paramType, value);
            binder.getBindingErrorProcessor().processPropertyAccessException(ex, binder.getBindingResult());
            bindingFailure = true;
        }
    }
    if (bindingFailure) {
        BindingResult result = binder.getBindingResult();
        for (int i = 0; i < paramNames.length; i++) {
            String paramName = paramNames[i];
            if (!failedParams.contains(paramName)) {
                Object value = args[i];
                result.recordFieldValue(paramName, paramTypes[i], value);
                validateValueIfApplicable(binder, parameter, ctor.getDeclaringClass(), paramName, value);
            } 
        }
        throw new BindException(result);
    } 
    return BeanUtils.instantiateClass(ctor, args);
}
org.springframework.web.method.annotation.ModelAttributeMethodProcessor

@Deprecated @Nullable protected Object constructAttribute(Constructor<?> ctor, String attributeName, WebDataBinderFactory binderFactory, NativeWebRequest webRequest)

{
    return null;
}
org.springframework.web.method.annotation.ModelAttributeMethodProcessor

protected Object createAttribute(String attributeName, MethodParameter parameter, WebDataBinderFactory binderFactory, NativeWebRequest webRequest)

{
    MethodParameter nestedParameter = parameter.nestedIfOptional();
    Class<?> clazz = nestedParameter.getNestedParameterType();
    Constructor<?> ctor = BeanUtils.findPrimaryConstructor(clazz);
    if (ctor == null) {
        Constructor<?>[] ctors = clazz.getConstructors();
        if (ctors.length == 1) {
            ctor = ctors[0];
        } else {
            try {
                ctor = clazz.getDeclaredConstructor();
            } catch (NoSuchMethodException ex) {
                throw new IllegalStateException("No primary or default constructor found for " + clazz, ex);
            }
        }
    } 
    Object attribute = constructAttribute(ctor, attributeName, parameter, binderFactory, webRequest);
    if (parameter != nestedParameter) {
        attribute = Optional.of(attribute);
    } 
    return attribute;
}
org.springframework.web.method.annotation.ModelAttributeMethodProcessor

@Override public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest)

{
    if (returnValue != null) {
        String name = ModelFactory.getNameForReturnValue(returnValue, returnType);
        mavContainer.addAttribute(name, returnValue);
    } 
}
org.springframework.web.method.annotation.ModelAttributeMethodProcessor

protected boolean isBindExceptionRequired(WebDataBinder binder, MethodParameter parameter)

{
    return isBindExceptionRequired(parameter);
}
org.springframework.web.method.annotation.ModelAttributeMethodProcessor

protected final Log logger

org.springframework.web.method.annotation.ModelAttributeMethodProcessor

@Override @Nullable public final Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory)

{
    Assert.state(mavContainer != null, "ModelAttributeMethodProcessor requires ModelAndViewContainer");
    Assert.state(binderFactory != null, "ModelAttributeMethodProcessor requires WebDataBinderFactory");
    String name = ModelFactory.getNameForParameter(parameter);
    ModelAttribute ann = parameter.getParameterAnnotation(ModelAttribute.class);
    if (ann != null) {
        mavContainer.setBinding(name, ann.binding());
    } 
    Object attribute = null;
    BindingResult bindingResult = null;
    if (mavContainer.containsAttribute(name)) {
        attribute = mavContainer.getModel().get(name);
    } else {
        try {
            attribute = createAttribute(name, parameter, binderFactory, webRequest);
        } catch (BindException ex) {
            if (isBindExceptionRequired(parameter)) {
                throw ex;
            } 
            if (parameter.getParameterType() == Optional.class) {
                attribute = Optional.empty();
            } 
            bindingResult = ex.getBindingResult();
        }
    }
    if (bindingResult == null) {
        WebDataBinder binder = binderFactory.createBinder(webRequest, attribute, name);
        if (binder.getTarget() != null) {
            if (!mavContainer.isBindingDisabled(name)) {
                bindRequestParameters(binder, webRequest);
            } 
            validateIfApplicable(binder, parameter);
            if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
                throw new BindException(binder.getBindingResult());
            } 
        } 
        if (!parameter.getParameterType().isInstance(attribute)) {
            attribute = binder.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter);
        } 
        bindingResult = binder.getBindingResult();
    } 
    Map<String, Object> bindingResultModel = bindingResult.getModel();
    mavContainer.removeAttributes(bindingResultModel);
    mavContainer.addAllAttributes(bindingResultModel);
    return attribute;
}
org.springframework.web.method.annotation.ModelAttributeMethodProcessor

@Override public boolean supportsParameter(MethodParameter parameter)

{
    return (parameter.hasParameterAnnotation(ModelAttribute.class) || (this.annotationNotRequired && !BeanUtils.isSimpleProperty(parameter.getParameterType())));
}
org.springframework.web.method.annotation.ModelAttributeMethodProcessor

@Override public boolean supportsReturnType(MethodParameter returnType)

{
    return (returnType.hasMethodAnnotation(ModelAttribute.class) || (this.annotationNotRequired && !BeanUtils.isSimpleProperty(returnType.getParameterType())));
}
org.springframework.web.method.annotation.ModelAttributeMethodProcessor

protected void validateIfApplicable(WebDataBinder binder, MethodParameter parameter)

{
    for (Annotation ann: parameter.getParameterAnnotations()) {
        Object[] validationHints = determineValidationHints(ann);
        if (validationHints != null) {
            binder.validate(validationHints);
            break;
        } 
    }
}
org.springframework.web.method.annotation.ModelAttributeMethodProcessor

protected void validateValueIfApplicable(WebDataBinder binder, MethodParameter parameter, Class<?> targetType, String fieldName, @Nullable Object value)

{
    for (Annotation ann: parameter.getParameterAnnotations()) {
        Object[] validationHints = determineValidationHints(ann);
        if (validationHints != null) {
            for (Validator validator: binder.getValidators()) {
                if (validator instanceof SmartValidator) {
                    try {
                        ((SmartValidator)validator).validateValue(targetType, fieldName, value, binder.getBindingResult(), validationHints);
                    } catch (IllegalArgumentException ex) {
                    }
                } 
            }
            break;
        } 
    }
}

ModelFactory

org.springframework.web.method.annotation.ModelFactory

public ModelFactory ModelFactory(@Nullable List<InvocableHandlerMethod> handlerMethods, WebDataBinderFactory binderFactory, SessionAttributesHandler attributeHandler)

{
    if (handlerMethods != null) {
        for (InvocableHandlerMethod handlerMethod: handlerMethods) {
            this.modelMethods.add(new ModelMethod(handlerMethod));
        }
    } 
    this.dataBinderFactory = binderFactory;
    this.sessionAttributesHandler = attributeHandler;
}
org.springframework.web.method.annotation.ModelFactory

public void updateModel(NativeWebRequest request, ModelAndViewContainer container)

{
    ModelMap defaultModel = container.getDefaultModel();
    if (container.getSessionStatus().isComplete()) {
        this.sessionAttributesHandler.cleanupAttributes(request);
    } else {
        this.sessionAttributesHandler.storeAttributes(request, defaultModel);
    }
    if (!container.isRequestHandled() && container.getModel() == defaultModel) {
        updateBindingResult(request, defaultModel);
    } 
}

ModelMethodProcessor
implements HandlerMethodArgumentResolver, HandlerMethodReturnValueHandler

org.springframework.web.method.annotation.ModelMethodProcessor

@Override public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest)

{
    if (returnValue == null) {
        return ;
    } else if (returnValue instanceof Model) {
        mavContainer.addAllAttributes(((Model)returnValue).asMap());
    } else {
        throw new UnsupportedOperationException("Unexpected return type: " + returnType.getParameterType().getName() + " in method: " + returnType.getMethod());
    }
}
org.springframework.web.method.annotation.ModelMethodProcessor

@Override @Nullable public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory)

{
    Assert.state(mavContainer != null, "ModelAndViewContainer is required for model exposure");
    return mavContainer.getModel();
}
org.springframework.web.method.annotation.ModelMethodProcessor

@Override public boolean supportsParameter(MethodParameter parameter)

{
    return Model.class.isAssignableFrom(parameter.getParameterType());
}
org.springframework.web.method.annotation.ModelMethodProcessor

@Override public boolean supportsReturnType(MethodParameter returnType)

{
    return Model.class.isAssignableFrom(returnType.getParameterType());
}

RequestHeaderMapMethodArgumentResolver
implements HandlerMethodArgumentResolver

org.springframework.web.method.annotation.RequestHeaderMapMethodArgumentResolver

@Override public boolean supportsParameter(MethodParameter parameter)

{
    return (parameter.hasParameterAnnotation(RequestHeader.class) && Map.class.isAssignableFrom(parameter.getParameterType()));
}

RequestHeaderMethodArgumentResolver
extends AbstractNamedValueMethodArgumentResolver

org.springframework.web.method.annotation.RequestHeaderMethodArgumentResolver

public RequestHeaderMethodArgumentResolver RequestHeaderMethodArgumentResolver(@Nullable ConfigurableBeanFactory beanFactory)

{
    super(beanFactory);
}
org.springframework.web.method.annotation.RequestHeaderMethodArgumentResolver

@Override protected NamedValueInfo createNamedValueInfo(MethodParameter parameter)

{
    RequestHeader ann = parameter.getParameterAnnotation(RequestHeader.class);
    Assert.state(ann != null, "No RequestHeader annotation");
    return new RequestHeaderNamedValueInfo(ann);
}
org.springframework.web.method.annotation.RequestHeaderMethodArgumentResolver

@Override protected void handleMissingValue(String name, MethodParameter parameter)

{
    throw new MissingRequestHeaderException(name, parameter);
}
org.springframework.web.method.annotation.RequestHeaderMethodArgumentResolver

@Override @Nullable protected Object resolveName(String name, MethodParameter parameter, NativeWebRequest request)

{
    String[] headerValues = request.getHeaderValues(name);
    if (headerValues != null) {
        return (headerValues.length == 1 ? headerValues[0] : headerValues);
    } else {
        return null;
    }
}
org.springframework.web.method.annotation.RequestHeaderMethodArgumentResolver

@Override public boolean supportsParameter(MethodParameter parameter)

{
    return (parameter.hasParameterAnnotation(RequestHeader.class) && !Map.class.isAssignableFrom(parameter.nestedIfOptional().getNestedParameterType()));
}

RequestParamMapMethodArgumentResolver
implements HandlerMethodArgumentResolver

org.springframework.web.method.annotation.RequestParamMapMethodArgumentResolver

@Override public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory)

{
    ResolvableType resolvableType = ResolvableType.forMethodParameter(parameter);
    if (MultiValueMap.class.isAssignableFrom(parameter.getParameterType())) {
        Class<?> valueType = resolvableType.as(MultiValueMap.class).getGeneric(1).resolve();
        if (valueType == MultipartFile.class) {
            MultipartRequest multipartRequest = MultipartResolutionDelegate.resolveMultipartRequest(webRequest);
            return (multipartRequest != null ? multipartRequest.getMultiFileMap() : new LinkedMultiValueMap<>(0));
        } else if (valueType == Part.class) {
            HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
            if (servletRequest != null && MultipartResolutionDelegate.isMultipartRequest(servletRequest)) {
                Collection<Part> parts = servletRequest.getParts();
                LinkedMultiValueMap<String, Part> result = new LinkedMultiValueMap<>(parts.size());
                for (Part part: parts) {
                    result.add(part.getName(), part);
                }
                return result;
            } 
            return new LinkedMultiValueMap<>(0);
        } else {
            Map<String, String[]> parameterMap = webRequest.getParameterMap();
            MultiValueMap<String, String> result = new LinkedMultiValueMap<>(parameterMap.size());
            parameterMap.forEach((key, values) -> {
                for (String value: values) {
                    result.add(key, value);
                }
            });
            return result;
        }
    } else {
        Class<?> valueType = resolvableType.asMap().getGeneric(1).resolve();
        if (valueType == MultipartFile.class) {
            MultipartRequest multipartRequest = MultipartResolutionDelegate.resolveMultipartRequest(webRequest);
            return (multipartRequest != null ? multipartRequest.getFileMap() : new LinkedHashMap<>(0));
        } else if (valueType == Part.class) {
            HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
            if (servletRequest != null && MultipartResolutionDelegate.isMultipartRequest(servletRequest)) {
                Collection<Part> parts = servletRequest.getParts();
                LinkedHashMap<String, Part> result = new LinkedHashMap<>(parts.size());
                for (Part part: parts) {
                    if (!result.containsKey(part.getName())) {
                        result.put(part.getName(), part);
                    } 
                }
                return result;
            } 
            return new LinkedHashMap<>(0);
        } else {
            Map<String, String[]> parameterMap = webRequest.getParameterMap();
            Map<String, String> result = new LinkedHashMap<>(parameterMap.size());
            parameterMap.forEach((key, values) -> {
                if (values.length > 0) {
                    result.put(key, values[0]);
                } 
            });
            return result;
        }
    }
}
org.springframework.web.method.annotation.RequestParamMapMethodArgumentResolver

@Override public boolean supportsParameter(MethodParameter parameter)

{
    RequestParam requestParam = parameter.getParameterAnnotation(RequestParam.class);
    return (requestParam != null && Map.class.isAssignableFrom(parameter.getParameterType()) && !StringUtils.hasText(requestParam.name()));
}

RequestParamMethodArgumentResolver
extends AbstractNamedValueMethodArgumentResolver implements UriComponentsContributor

org.springframework.web.method.annotation.RequestParamMethodArgumentResolver

public RequestParamMethodArgumentResolver RequestParamMethodArgumentResolver(boolean useDefaultResolution)

{
    this.useDefaultResolution = useDefaultResolution;
}
org.springframework.web.method.annotation.RequestParamMethodArgumentResolver

public RequestParamMethodArgumentResolver RequestParamMethodArgumentResolver(@Nullable ConfigurableBeanFactory beanFactory, boolean useDefaultResolution)

{
    super(beanFactory);
    this.useDefaultResolution = useDefaultResolution;
}
org.springframework.web.method.annotation.RequestParamMethodArgumentResolver

@Override public void contributeMethodArgument(MethodParameter parameter, @Nullable Object value, UriComponentsBuilder builder, Map<String, Object> uriVariables, ConversionService conversionService)

{
    Class<?> paramType = parameter.getNestedParameterType();
    if (Map.class.isAssignableFrom(paramType) || MultipartFile.class == paramType || Part.class == paramType) {
        return ;
    } 
    RequestParam requestParam = parameter.getParameterAnnotation(RequestParam.class);
    String name = (requestParam != null && StringUtils.hasLength(requestParam.name()) ? requestParam.name() : parameter.getParameterName());
    Assert.state(name != null, "Unresolvable parameter name");
    parameter = parameter.nestedIfOptional();
    if (value instanceof Optional) {
        value = ((Optional<?>)value).orElse(null);
    } 
    if (value == null) {
        if (requestParam != null && (!requestParam.required() || !requestParam.defaultValue().equals(ValueConstants.DEFAULT_NONE))) {
            return ;
        } 
        builder.queryParam(name);
    } else if (value instanceof Collection) {
        for (Object element: (Collection<?>)value) {
            element = formatUriValue(conversionService, TypeDescriptor.nested(parameter, 1), element);
            builder.queryParam(name, element);
        }
    } else {
        builder.queryParam(name, formatUriValue(conversionService, new TypeDescriptor(parameter), value));
    }
}
org.springframework.web.method.annotation.RequestParamMethodArgumentResolver

@Override protected NamedValueInfo createNamedValueInfo(MethodParameter parameter)

{
    RequestParam ann = parameter.getParameterAnnotation(RequestParam.class);
    return (ann != null ? new RequestParamNamedValueInfo(ann) : new RequestParamNamedValueInfo());
}
org.springframework.web.method.annotation.RequestParamMethodArgumentResolver

@Nullable protected String formatUriValue(@Nullable ConversionService cs, @Nullable TypeDescriptor sourceType, @Nullable Object value)

{
    if (value == null) {
        return null;
    } else if (value instanceof String) {
        return (String)value;
    } else if (cs != null) {
        return (String)cs.convert(value, sourceType, STRING_TYPE_DESCRIPTOR);
    } else {
        return value.toString();
    }
}

SessionAttributesHandler

org.springframework.web.method.annotation.SessionAttributesHandler

public void cleanupAttributes(WebRequest request)

{
    for (String attributeName: this.knownAttributeNames) {
        this.sessionAttributeStore.cleanupAttribute(request, attributeName);
    }
}
org.springframework.web.method.annotation.SessionAttributesHandler

public boolean hasSessionAttributes()

{
    return (!this.attributeNames.isEmpty() || !this.attributeTypes.isEmpty());
}
org.springframework.web.method.annotation.SessionAttributesHandler

public Map<String, Object> retrieveAttributes(WebRequest request)

{
    Map<String, Object> attributes = new HashMap<>();
    for (String name: this.knownAttributeNames) {
        Object value = this.sessionAttributeStore.retrieveAttribute(request, name);
        if (value != null) {
            attributes.put(name, value);
        } 
    }
    return attributes;
}
org.springframework.web.method.annotation.SessionAttributesHandler

public void storeAttributes(WebRequest request, Map<String, ?> attributes)

{
    attributes.forEach((name, value) -> {
        if (value != null && isHandlerSessionAttribute(name, value.getClass())) {
            this.sessionAttributeStore.storeAttribute(request, name, value);
        } 
    });
}

SessionStatusMethodArgumentResolver
implements HandlerMethodArgumentResolver

org.springframework.web.method.annotation.SessionStatusMethodArgumentResolver

@Override public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory)

{
    Assert.state(mavContainer != null, "ModelAndViewContainer is required for session status exposure");
    return mavContainer.getSessionStatus();
}
org.springframework.web.method.annotation.SessionStatusMethodArgumentResolver

@Override public boolean supportsParameter(MethodParameter parameter)

{
    return SessionStatus.class == parameter.getParameterType();
}



AsyncHandlerMethodReturnValueHandler
inherit classes
  • HandlerMethodReturnValueHandler

CompositeUriComponentsContributor
implements UriComponentsContributor

org.springframework.web.method.support.CompositeUriComponentsContributor

public CompositeUriComponentsContributor CompositeUriComponentsContributor(UriComponentsContributor... contributors)

{
    Collections.addAll(this.contributors, contributors);
    this.conversionService = new DefaultFormattingConversionService();
}
org.springframework.web.method.support.CompositeUriComponentsContributor

public CompositeUriComponentsContributor CompositeUriComponentsContributor(Collection<?> contributors)

{
    this(contributors, null);
}
org.springframework.web.method.support.CompositeUriComponentsContributor

public CompositeUriComponentsContributor CompositeUriComponentsContributor(@Nullable Collection<?> contributors, @Nullable ConversionService cs)

{
    if (contributors != null) {
        this.contributors.addAll(contributors);
    } 
    this.conversionService = (cs != null ? cs : new DefaultFormattingConversionService());
}
org.springframework.web.method.support.CompositeUriComponentsContributor

@Override public void contributeMethodArgument(MethodParameter parameter, Object value, UriComponentsBuilder builder, Map<String, Object> uriVariables, ConversionService conversionService)

{
    for (Object contributor: this.contributors) {
        if (contributor instanceof UriComponentsContributor) {
            UriComponentsContributor ucc = (UriComponentsContributor)contributor;
            if (ucc.supportsParameter(parameter)) {
                ucc.contributeMethodArgument(parameter, value, builder, uriVariables, conversionService);
                break;
            } 
        } else if (contributor instanceof HandlerMethodArgumentResolver) {
            if (((HandlerMethodArgumentResolver)contributor).supportsParameter(parameter)) {
                break;
            } 
        } 
    }
}
org.springframework.web.method.support.CompositeUriComponentsContributor

public void contributeMethodArgument(MethodParameter parameter, Object value, UriComponentsBuilder builder, Map<String, Object> uriVariables)

{
    this.contributeMethodArgument(parameter, value, builder, uriVariables, this.conversionService);
}
org.springframework.web.method.support.CompositeUriComponentsContributor

public boolean hasContributors()

{
    return this.contributors.isEmpty();
}
org.springframework.web.method.support.CompositeUriComponentsContributor

@Override public boolean supportsParameter(MethodParameter parameter)

{
    for (Object contributor: this.contributors) {
        if (contributor instanceof UriComponentsContributor) {
            if (((UriComponentsContributor)contributor).supportsParameter(parameter)) {
                return true;
            } 
        } else if (contributor instanceof HandlerMethodArgumentResolver) {
            if (((HandlerMethodArgumentResolver)contributor).supportsParameter(parameter)) {
                return false;
            } 
        } 
    }
    return false;
}

HandlerMethodArgumentResolver

HandlerMethodArgumentResolverComposite
implements HandlerMethodArgumentResolver

org.springframework.web.method.support.HandlerMethodArgumentResolverComposite

public HandlerMethodArgumentResolverComposite addResolver(HandlerMethodArgumentResolver resolver)

{
    this.argumentResolvers.add(resolver);
    return this;
}
org.springframework.web.method.support.HandlerMethodArgumentResolverComposite

public HandlerMethodArgumentResolverComposite addResolvers(@Nullable HandlerMethodArgumentResolver... resolvers)

{
    if (resolvers != null) {
        Collections.addAll(this.argumentResolvers, resolvers);
    } 
    return this;
}
org.springframework.web.method.support.HandlerMethodArgumentResolverComposite

public HandlerMethodArgumentResolverComposite addResolvers(@Nullable List<?> resolvers)

{
    if (resolvers != null) {
        this.argumentResolvers.addAll(resolvers);
    } 
    return this;
}
org.springframework.web.method.support.HandlerMethodArgumentResolverComposite

public void clear()

{
    this.argumentResolvers.clear();
}
org.springframework.web.method.support.HandlerMethodArgumentResolverComposite

public List<HandlerMethodArgumentResolver> getResolvers()

{
    return Collections.unmodifiableList(this.argumentResolvers);
}
org.springframework.web.method.support.HandlerMethodArgumentResolverComposite

@Override @Nullable public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory)

{
    HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
    if (resolver == null) {
        throw new IllegalArgumentException("Unsupported parameter type [" + parameter.getParameterType().getName() + "]. supportsParameter should be called first.");
    } 
    return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
}
org.springframework.web.method.support.HandlerMethodArgumentResolverComposite

@Override public boolean supportsParameter(MethodParameter parameter)

{
    return getArgumentResolver(parameter) != null;
}

HandlerMethodReturnValueHandler

HandlerMethodReturnValueHandlerComposite
implements HandlerMethodReturnValueHandler

org.springframework.web.method.support.HandlerMethodReturnValueHandlerComposite

public HandlerMethodReturnValueHandlerComposite addHandler(HandlerMethodReturnValueHandler handler)

{
    this.returnValueHandlers.add(handler);
    return this;
}
org.springframework.web.method.support.HandlerMethodReturnValueHandlerComposite

public HandlerMethodReturnValueHandlerComposite addHandlers(@Nullable List<?> handlers)

{
    if (handlers != null) {
        this.returnValueHandlers.addAll(handlers);
    } 
    return this;
}
org.springframework.web.method.support.HandlerMethodReturnValueHandlerComposite

public List<HandlerMethodReturnValueHandler> getHandlers()

{
    return Collections.unmodifiableList(this.returnValueHandlers);
}
org.springframework.web.method.support.HandlerMethodReturnValueHandlerComposite

@Override public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest)

{
    HandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType);
    if (handler == null) {
        throw new IllegalArgumentException("Unknown return value type: " + returnType.getParameterType().getName());
    } 
    handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
}
org.springframework.web.method.support.HandlerMethodReturnValueHandlerComposite

protected final Log logger

org.springframework.web.method.support.HandlerMethodReturnValueHandlerComposite

@Override public boolean supportsReturnType(MethodParameter returnType)

{
    return getReturnValueHandler(returnType) != null;
}

InvocableHandlerMethod
extends HandlerMethod

org.springframework.web.method.support.InvocableHandlerMethod

public InvocableHandlerMethod InvocableHandlerMethod(HandlerMethod handlerMethod)

{
    super(handlerMethod);
}
org.springframework.web.method.support.InvocableHandlerMethod

public InvocableHandlerMethod InvocableHandlerMethod(Object bean, Method method)

{
    super(bean, method);
}
org.springframework.web.method.support.InvocableHandlerMethod

public InvocableHandlerMethod InvocableHandlerMethod(Object bean, String methodName, Class<?>... parameterTypes)

{
    super(bean, methodName, parameterTypes);
}
org.springframework.web.method.support.InvocableHandlerMethod

@Nullable public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, Object... providedArgs)

{
    Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
    if (logger.isTraceEnabled()) {
        logger.trace("Arguments: " + Arrays.toString(args));
    } 
    return doInvoke(args);
}
org.springframework.web.method.support.InvocableHandlerMethod

public void setDataBinderFactory(WebDataBinderFactory dataBinderFactory)

{
    this.dataBinderFactory = dataBinderFactory;
}
org.springframework.web.method.support.InvocableHandlerMethod

public void setHandlerMethodArgumentResolvers(HandlerMethodArgumentResolverComposite argumentResolvers)

{
    this.resolvers = argumentResolvers;
}
org.springframework.web.method.support.InvocableHandlerMethod

public void setParameterNameDiscoverer(ParameterNameDiscoverer parameterNameDiscoverer)

{
    this.parameterNameDiscoverer = parameterNameDiscoverer;
}

ModelAndViewContainer

org.springframework.web.method.support.ModelAndViewContainer

public ModelAndViewContainer addAllAttributes(@Nullable Map<String, ?> attributes)

{
    getModel().addAllAttributes(attributes);
    return this;
}
org.springframework.web.method.support.ModelAndViewContainer

public ModelAndViewContainer addAttribute(String name, @Nullable Object value)

{
    getModel().addAttribute(name, value);
    return this;
}
org.springframework.web.method.support.ModelAndViewContainer

public ModelAndViewContainer addAttribute(Object value)

{
    getModel().addAttribute(value);
    return this;
}
org.springframework.web.method.support.ModelAndViewContainer

public boolean containsAttribute(String name)

{
    return getModel().containsAttribute(name);
}
org.springframework.web.method.support.ModelAndViewContainer

public ModelMap getDefaultModel()

{
    return this.defaultModel;
}
org.springframework.web.method.support.ModelAndViewContainer

public ModelMap getModel()

{
    if (useDefaultModel()) {
        return this.defaultModel;
    } else {
        if (this.redirectModel == null) {
            this.redirectModel = new ModelMap();
        } 
        return this.redirectModel;
    }
}
org.springframework.web.method.support.ModelAndViewContainer

public SessionStatus getSessionStatus()

{
    return this.sessionStatus;
}
org.springframework.web.method.support.ModelAndViewContainer

@Nullable public HttpStatus getStatus()

{
    return this.status;
}
org.springframework.web.method.support.ModelAndViewContainer

@Nullable public Object getView()

{
    return this.view;
}
org.springframework.web.method.support.ModelAndViewContainer

@Nullable public String getViewName()

{
    return (this.view instanceof String ? (String)this.view : null);
}
org.springframework.web.method.support.ModelAndViewContainer

public boolean isBindingDisabled(String name)

{
    return (this.bindingDisabled.contains(name) || this.noBinding.contains(name));
}
org.springframework.web.method.support.ModelAndViewContainer

public boolean isRequestHandled()

{
    return this.requestHandled;
}
org.springframework.web.method.support.ModelAndViewContainer

public boolean isViewReference()

{
    return (this.view instanceof String);
}
org.springframework.web.method.support.ModelAndViewContainer

public ModelAndViewContainer mergeAttributes(@Nullable Map<String, ?> attributes)

{
    getModel().mergeAttributes(attributes);
    return this;
}
org.springframework.web.method.support.ModelAndViewContainer

public ModelAndViewContainer removeAttributes(@Nullable Map<String, ?> attributes)

{
    if (attributes != null) {
        for (String key: attributes.keySet()) {
            getModel().remove(key);
        }
    } 
    return this;
}
org.springframework.web.method.support.ModelAndViewContainer

public void setBinding(String attributeName, boolean enabled)

{
    if (!enabled) {
        this.noBinding.add(attributeName);
    } else {
        this.noBinding.remove(attributeName);
    }
}
org.springframework.web.method.support.ModelAndViewContainer

public void setBindingDisabled(String attributeName)

{
    this.bindingDisabled.add(attributeName);
}
org.springframework.web.method.support.ModelAndViewContainer

public void setIgnoreDefaultModelOnRedirect(boolean ignoreDefaultModelOnRedirect)

{
    this.ignoreDefaultModelOnRedirect = ignoreDefaultModelOnRedirect;
}
org.springframework.web.method.support.ModelAndViewContainer

public void setRedirectModel(ModelMap redirectModel)

{
    this.redirectModel = redirectModel;
}
org.springframework.web.method.support.ModelAndViewContainer

public void setRedirectModelScenario(boolean redirectModelScenario)

{
    this.redirectModelScenario = redirectModelScenario;
}
org.springframework.web.method.support.ModelAndViewContainer

public void setRequestHandled(boolean requestHandled)

{
    this.requestHandled = requestHandled;
}
org.springframework.web.method.support.ModelAndViewContainer

public void setStatus(@Nullable HttpStatus status)

{
    this.status = status;
}
org.springframework.web.method.support.ModelAndViewContainer

public void setView(@Nullable Object view)

{
    this.view = view;
}
org.springframework.web.method.support.ModelAndViewContainer

public void setViewName(@Nullable String viewName)

{
    this.view = viewName;
}

UriComponentsContributor


MaxUploadSizeExceededException
extends MultipartException

org.springframework.web.multipart.MaxUploadSizeExceededException

public MaxUploadSizeExceededException MaxUploadSizeExceededException(long maxUploadSize)

{
    this(maxUploadSize, null);
}
org.springframework.web.multipart.MaxUploadSizeExceededException

public MaxUploadSizeExceededException MaxUploadSizeExceededException(long maxUploadSize, @Nullable Throwable ex)

{
    super("Maximum upload size " + (maxUploadSize >= 0 ? "of " + maxUploadSize + " bytes " : "") + "exceeded", ex);
    this.maxUploadSize = maxUploadSize;
}
org.springframework.web.multipart.MaxUploadSizeExceededException

public long getMaxUploadSize()

{
    return this.maxUploadSize;
}

MultipartException
extends NestedRuntimeException

org.springframework.web.multipart.MultipartException

public MultipartException MultipartException(String msg)

{
    super(msg);
}
org.springframework.web.multipart.MultipartException

public MultipartException MultipartException(String msg, @Nullable Throwable cause)

{
    super(msg, cause);
}

MultipartFile
inherit classes
  • InputStreamSource

MultipartFileResource
extends AbstractResource

org.springframework.web.multipart.MultipartFileResource

public MultipartFileResource MultipartFileResource(MultipartFile multipartFile)

{
    Assert.notNull(multipartFile, "MultipartFile must not be null");
    this.multipartFile = multipartFile;
}
org.springframework.web.multipart.MultipartFileResource

@Override public long contentLength()

{
    return this.multipartFile.getSize();
}
org.springframework.web.multipart.MultipartFileResource

@Override public boolean equals(@Nullable Object other)

{
    return (this == other || (other instanceof MultipartFileResource && ((MultipartFileResource)other).multipartFile.equals(this.multipartFile)));
}
org.springframework.web.multipart.MultipartFileResource

@Override public boolean exists()

{
    return true;
}
org.springframework.web.multipart.MultipartFileResource

@Override public String getDescription()

{
    return "MultipartFile resource [" + this.multipartFile.getName() + "]";
}
org.springframework.web.multipart.MultipartFileResource

@Override public String getFilename()

{
    return this.multipartFile.getOriginalFilename();
}
org.springframework.web.multipart.MultipartFileResource

@Override public InputStream getInputStream()

{
    return this.multipartFile.getInputStream();
}
org.springframework.web.multipart.MultipartFileResource

@Override public int hashCode()

{
    return this.multipartFile.hashCode();
}
org.springframework.web.multipart.MultipartFileResource

@Override public boolean isOpen()

{
    return true;
}

MultipartHttpServletRequest
inherit classes
  • HttpServletRequest
  • MultipartRequest

MultipartRequest

MultipartResolver

CommonsFileUploadSupport

org.springframework.web.multipart.commons.CommonsFileUploadSupport

public CommonsFileUploadSupport CommonsFileUploadSupport()

{
    this.fileItemFactory = newFileItemFactory();
    this.fileUpload = newFileUpload(getFileItemFactory());
}
MultipartParsingResult

org.springframework.web.multipart.commons.CommonsFileUploadSupport.MultipartParsingResult

public MultipartParsingResult MultipartParsingResult(MultiValueMap<String, MultipartFile> mpFiles, Map<String, String[]> mpParams, Map<String, String> mpParamContentTypes)

{
    this.multipartFiles = mpFiles;
    this.multipartParameters = mpParams;
    this.multipartParameterContentTypes = mpParamContentTypes;
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport.MultipartParsingResult

public MultiValueMap<String, MultipartFile> getMultipartFiles()

{
    return this.multipartFiles;
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport.MultipartParsingResult

public Map<String, String> getMultipartParameterContentTypes()

{
    return this.multipartParameterContentTypes;
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport.MultipartParsingResult

public Map<String, String[]> getMultipartParameters()

{
    return this.multipartParameters;
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport

protected CommonsMultipartFile createMultipartFile(FileItem fileItem)

{
    CommonsMultipartFile multipartFile = new CommonsMultipartFile(fileItem);
    multipartFile.setPreserveFilename(this.preserveFilename);
    return multipartFile;
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport

protected String getDefaultEncoding()

{
    String encoding = getFileUpload().getHeaderEncoding();
    if (encoding == null) {
        encoding = WebUtils.DEFAULT_CHARACTER_ENCODING;
    } 
    return encoding;
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport

public DiskFileItemFactory getFileItemFactory()

{
    return this.fileItemFactory;
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport

public FileUpload getFileUpload()

{
    return this.fileUpload;
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport

protected boolean isUploadTempDirSpecified()

{
    return this.uploadTempDirSpecified;
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport

protected final Log logger

org.springframework.web.multipart.commons.CommonsFileUploadSupport

protected DiskFileItemFactory newFileItemFactory()

{
    return new DiskFileItemFactory();
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport

protected abstract FileUpload newFileUpload(FileItemFactory fileItemFactory)

org.springframework.web.multipart.commons.CommonsFileUploadSupport

protected MultipartParsingResult parseFileItems(List<FileItem> fileItems, String encoding)

{
    MultiValueMap<String, MultipartFile> multipartFiles = new LinkedMultiValueMap<>();
    Map<String, String[]> multipartParameters = new HashMap<>();
    Map<String, String> multipartParameterContentTypes = new HashMap<>();
    for (FileItem fileItem: fileItems) {
        if (fileItem.isFormField()) {
            String value;
            String partEncoding = determineEncoding(fileItem.getContentType(), encoding);
            try {
                value = fileItem.getString(partEncoding);
            } catch (UnsupportedEncodingException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Could not decode multipart item '" + fileItem.getFieldName() + "' with encoding '" + partEncoding + "': using platform default");
                } 
                value = fileItem.getString();
            }
            String[] curParam = multipartParameters.get(fileItem.getFieldName());
            if (curParam == null) {
                multipartParameters.put(fileItem.getFieldName(), new String[]{value});
            } else {
                String[] newParam = StringUtils.addStringToArray(curParam, value);
                multipartParameters.put(fileItem.getFieldName(), newParam);
            }
            multipartParameterContentTypes.put(fileItem.getFieldName(), fileItem.getContentType());
        } else {
            CommonsMultipartFile file = createMultipartFile(fileItem);
            multipartFiles.add(file.getName(), file);
            LogFormatUtils.traceDebug(logger, traceOn -> "Part '" + file.getName() + "', size " + file.getSize() + " bytes, filename='" + file.getOriginalFilename() + "'" + (traceOn ? ", storage=" + file.getStorageDescription() : ""));
        }
    }
    return new MultipartParsingResult(multipartFiles, multipartParameters, multipartParameterContentTypes);
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport

public void setDefaultEncoding(String defaultEncoding)

{
    this.fileUpload.setHeaderEncoding(defaultEncoding);
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport

public void setMaxInMemorySize(int maxInMemorySize)

{
    this.fileItemFactory.setSizeThreshold(maxInMemorySize);
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport

public void setMaxUploadSize(long maxUploadSize)

{
    this.fileUpload.setSizeMax(maxUploadSize);
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport

public void setMaxUploadSizePerFile(long maxUploadSizePerFile)

{
    this.fileUpload.setFileSizeMax(maxUploadSizePerFile);
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport

public void setPreserveFilename(boolean preserveFilename)

{
    this.preserveFilename = preserveFilename;
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport

public void setUploadTempDir(Resource uploadTempDir)

{
    if (!uploadTempDir.exists() && !uploadTempDir.getFile().mkdirs()) {
        throw new IllegalArgumentException("Given uploadTempDir [" + uploadTempDir + "] could not be created");
    } 
    this.fileItemFactory.setRepository(uploadTempDir.getFile());
    this.uploadTempDirSpecified = true;
}

CommonsMultipartFile
implements MultipartFile, Serializable

org.springframework.web.multipart.commons.CommonsMultipartFile

public CommonsMultipartFile CommonsMultipartFile(FileItem fileItem)

{
    this.fileItem = fileItem;
    this.size = this.fileItem.getSize();
}
org.springframework.web.multipart.commons.CommonsMultipartFile

@Override public byte[] getBytes()

{
    if (!isAvailable()) {
        throw new IllegalStateException("File has been moved - cannot be read again");
    } 
    byte[] bytes = this.fileItem.get();
    return (bytes != null ? bytes : new byte[0]);
}
org.springframework.web.multipart.commons.CommonsMultipartFile

@Override public String getContentType()

{
    return this.fileItem.getContentType();
}
org.springframework.web.multipart.commons.CommonsMultipartFile

public final FileItem getFileItem()

{
    return this.fileItem;
}
org.springframework.web.multipart.commons.CommonsMultipartFile

@Override public InputStream getInputStream()

{
    if (!isAvailable()) {
        throw new IllegalStateException("File has been moved - cannot be read again");
    } 
    InputStream inputStream = this.fileItem.getInputStream();
    return (inputStream != null ? inputStream : StreamUtils.emptyInput());
}
org.springframework.web.multipart.commons.CommonsMultipartFile

@Override public String getName()

{
    return this.fileItem.getFieldName();
}
org.springframework.web.multipart.commons.CommonsMultipartFile

@Override public String getOriginalFilename()

{
    String filename = this.fileItem.getName();
    if (filename == null) {
        return "";
    } 
    if (this.preserveFilename) {
        return filename;
    } 
    int unixSep = filename.lastIndexOf('/');
    int winSep = filename.lastIndexOf('\\');
    int pos = Math.max(winSep, unixSep);
    if (pos != -1) {
        return filename.substring(pos + 1);
    } else {
        return filename;
    }
}
org.springframework.web.multipart.commons.CommonsMultipartFile

@Override public long getSize()

{
    return this.size;
}
org.springframework.web.multipart.commons.CommonsMultipartFile

public String getStorageDescription()

{
    if (this.fileItem.isInMemory()) {
        return "in memory";
    } else if (this.fileItem instanceof DiskFileItem) {
        return "at [" + ((DiskFileItem)this.fileItem).getStoreLocation().getAbsolutePath() + "]";
    } else {
        return "on disk";
    }
}
org.springframework.web.multipart.commons.CommonsMultipartFile

protected boolean isAvailable()

{
    if (this.fileItem.isInMemory()) {
        return true;
    } 
    if (this.fileItem instanceof DiskFileItem) {
        return ((DiskFileItem)this.fileItem).getStoreLocation().exists();
    } 
    return (this.fileItem.getSize() == this.size);
}
org.springframework.web.multipart.commons.CommonsMultipartFile

@Override public boolean isEmpty()

{
    return (this.size == 0);
}
org.springframework.web.multipart.commons.CommonsMultipartFile

protected static final Log logger

org.springframework.web.multipart.commons.CommonsMultipartFile

public void setPreserveFilename(boolean preserveFilename)

{
    this.preserveFilename = preserveFilename;
}
org.springframework.web.multipart.commons.CommonsMultipartFile

@Override public void transferTo(File dest)

{
    if (!isAvailable()) {
        throw new IllegalStateException("File has already been moved - cannot be transferred again");
    } 
    if (dest.exists() && !dest.delete()) {
        throw new IOException("Destination file [" + dest.getAbsolutePath() + "] already exists and could not be deleted");
    } 
    try {
        this.fileItem.write(dest);
        LogFormatUtils.traceDebug(logger, traceOn -> {
            String action = "transferred";
            if (!this.fileItem.isInMemory()) {
                action = (isAvailable() ? "copied" : "moved");
            } 
            return "Part '" + getName() + "',  filename '" + getOriginalFilename() + "'" + (traceOn ? ", stored " + getStorageDescription() : "") + ": " + action + " to [" + dest.getAbsolutePath() + "]";
        });
    } catch (FileUploadException ex) {
        throw new IllegalStateException(ex.getMessage(), ex);
    } catch (IllegalStateException | IOException ex) {
        throw ex;
    } catch (Exception ex) {
        throw new IOException("File transfer failed", ex);
    }
}
org.springframework.web.multipart.commons.CommonsMultipartFile

@Override public void transferTo(Path dest)

{
    if (!isAvailable()) {
        throw new IllegalStateException("File has already been moved - cannot be transferred again");
    } 
    FileCopyUtils.copy(this.fileItem.getInputStream(), Files.newOutputStream(dest));
}

CommonsMultipartResolver
extends CommonsFileUploadSupport implements MultipartResolver, ServletContextAware

org.springframework.web.multipart.commons.CommonsMultipartResolver

public CommonsMultipartResolver CommonsMultipartResolver()

{
    super();
}
org.springframework.web.multipart.commons.CommonsMultipartResolver

public CommonsMultipartResolver CommonsMultipartResolver(ServletContext servletContext)

{
    this();
    setServletContext(servletContext);
}
org.springframework.web.multipart.commons.CommonsMultipartResolver

protected String determineEncoding(HttpServletRequest request)

{
    String encoding = request.getCharacterEncoding();
    if (encoding == null) {
        encoding = getDefaultEncoding();
    } 
    return encoding;
}
org.springframework.web.multipart.commons.CommonsMultipartResolver

@Override public boolean isMultipart(HttpServletRequest request)

{
    return ServletFileUpload.isMultipartContent(request);
}
org.springframework.web.multipart.commons.CommonsMultipartResolver

@Override protected FileUpload newFileUpload(FileItemFactory fileItemFactory)

{
    return new ServletFileUpload(fileItemFactory);
}
org.springframework.web.multipart.commons.CommonsMultipartResolver

public void setResolveLazily(boolean resolveLazily)

{
    this.resolveLazily = resolveLazily;
}
org.springframework.web.multipart.commons.CommonsMultipartResolver

@Override public void setServletContext(ServletContext servletContext)

{
    if (!isUploadTempDirSpecified()) {
        getFileItemFactory().setRepository(WebUtils.getTempDir(servletContext));
    } 
}



AbstractMultipartHttpServletRequest
extends HttpServletRequestWrapper implements MultipartHttpServletRequest

org.springframework.web.multipart.support.AbstractMultipartHttpServletRequest

protected AbstractMultipartHttpServletRequest AbstractMultipartHttpServletRequest(HttpServletRequest request)

{
    super(request);
}
org.springframework.web.multipart.support.AbstractMultipartHttpServletRequest

@Override public MultipartFile getFile(String name)

{
    return getMultipartFiles().getFirst(name);
}
org.springframework.web.multipart.support.AbstractMultipartHttpServletRequest

@Override public Map<String, MultipartFile> getFileMap()

{
    return getMultipartFiles().toSingleValueMap();
}
org.springframework.web.multipart.support.AbstractMultipartHttpServletRequest

@Override public Iterator<String> getFileNames()

{
    return getMultipartFiles().keySet().iterator();
}
org.springframework.web.multipart.support.AbstractMultipartHttpServletRequest

@Override public List<MultipartFile> getFiles(String name)

{
    List<MultipartFile> multipartFiles = getMultipartFiles().get(name);
    if (multipartFiles != null) {
        return multipartFiles;
    } else {
        return Collections.emptyList();
    }
}
org.springframework.web.multipart.support.AbstractMultipartHttpServletRequest

@Override public MultiValueMap<String, MultipartFile> getMultiFileMap()

{
    return getMultipartFiles();
}
org.springframework.web.multipart.support.AbstractMultipartHttpServletRequest

protected MultiValueMap<String, MultipartFile> getMultipartFiles()

{
    if (this.multipartFiles == null) {
        initializeMultipart();
    } 
    return this.multipartFiles;
}
org.springframework.web.multipart.support.AbstractMultipartHttpServletRequest

@Override public HttpServletRequest getRequest()

{
    return (HttpServletRequest)super.getRequest();
}
org.springframework.web.multipart.support.AbstractMultipartHttpServletRequest

@Override public HttpMethod getRequestMethod()

{
    return HttpMethod.resolve(getRequest().getMethod());
}
org.springframework.web.multipart.support.AbstractMultipartHttpServletRequest

protected void initializeMultipart()

{
    throw new IllegalStateException("Multipart request not initialized");
}
org.springframework.web.multipart.support.AbstractMultipartHttpServletRequest

public boolean isResolved()

{
    return (this.multipartFiles != null);
}
org.springframework.web.multipart.support.AbstractMultipartHttpServletRequest

protected final void setMultipartFiles(MultiValueMap<String, MultipartFile> multipartFiles)

{
    this.multipartFiles = new LinkedMultiValueMap<>(Collections.unmodifiableMap(multipartFiles));
}

ByteArrayMultipartFileEditor
extends ByteArrayPropertyEditor

org.springframework.web.multipart.support.ByteArrayMultipartFileEditor

@Override public String getAsText()

{
    byte[] value = (byte[])getValue();
    return (value != null ? new String(value) : "");
}

DefaultMultipartHttpServletRequest
extends AbstractMultipartHttpServletRequest

org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest

public DefaultMultipartHttpServletRequest DefaultMultipartHttpServletRequest(HttpServletRequest request, MultiValueMap<String, MultipartFile> mpFiles, Map<String, String[]> mpParams, Map<String, String> mpParamContentTypes)

{
    super(request);
    setMultipartFiles(mpFiles);
    setMultipartParameters(mpParams);
    setMultipartParameterContentTypes(mpParamContentTypes);
}
org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest

public DefaultMultipartHttpServletRequest DefaultMultipartHttpServletRequest(HttpServletRequest request)

{
    super(request);
}
org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest

@Override public String getMultipartContentType(String paramOrFileName)

{
    MultipartFile file = getFile(paramOrFileName);
    if (file != null) {
        return file.getContentType();
    } else {
        return getMultipartParameterContentTypes().get(paramOrFileName);
    }
}
org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest

@Override public HttpHeaders getMultipartHeaders(String paramOrFileName)

{
    String contentType = getMultipartContentType(paramOrFileName);
    if (contentType != null) {
        HttpHeaders headers = new HttpHeaders();
        headers.add(CONTENT_TYPE, contentType);
        return headers;
    } else {
        return null;
    }
}
org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest

protected Map<String, String> getMultipartParameterContentTypes()

{
    if (this.multipartParameterContentTypes == null) {
        initializeMultipart();
    } 
    return this.multipartParameterContentTypes;
}
org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest

protected Map<String, String[]> getMultipartParameters()

{
    if (this.multipartParameters == null) {
        initializeMultipart();
    } 
    return this.multipartParameters;
}
org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest

@Override @Nullable public String getParameter(String name)

{
    String[] values = getMultipartParameters().get(name);
    if (values != null) {
        return (values.length > 0 ? values[0] : null);
    } 
    return super.getParameter(name);
}
org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest

@Override public Map<String, String[]> getParameterMap()

{
    Map<String, String[]> result = new LinkedHashMap<>();
    Enumeration<String> names = getParameterNames();
    while (names.hasMoreElements()) {
        String name = names.nextElement();
        result.put(name, getParameterValues(name));
    }
    return result;
}
org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest

@Override public Enumeration<String> getParameterNames()

{
    Map<String, String[]> multipartParameters = getMultipartParameters();
    if (multipartParameters.isEmpty()) {
        return super.getParameterNames();
    } 
    Set<String> paramNames = new LinkedHashSet<>();
    paramNames.addAll(Collections.list(super.getParameterNames()));
    paramNames.addAll(multipartParameters.keySet());
    return Collections.enumeration(paramNames);
}
org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest

protected final void setMultipartParameterContentTypes(Map<String, String> multipartParameterContentTypes)

{
    this.multipartParameterContentTypes = multipartParameterContentTypes;
}
org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest

protected final void setMultipartParameters(Map<String, String[]> multipartParameters)

{
    this.multipartParameters = multipartParameters;
}

MissingServletRequestPartException
extends ServletException

org.springframework.web.multipart.support.MissingServletRequestPartException

public MissingServletRequestPartException MissingServletRequestPartException(String partName)

{
    super("Required request part '" + partName + "' is not present");
    this.partName = partName;
}
org.springframework.web.multipart.support.MissingServletRequestPartException

public String getRequestPartName()

{
    return this.partName;
}

MultipartFilter
extends OncePerRequestFilter

org.springframework.web.multipart.support.MultipartFilter

public static final String DEFAULT_MULTIPART_RESOLVER_BEAN_NAME

org.springframework.web.multipart.support.MultipartFilter

protected String getMultipartResolverBeanName()

{
    return this.multipartResolverBeanName;
}
org.springframework.web.multipart.support.MultipartFilter

protected MultipartResolver lookupMultipartResolver(HttpServletRequest request)

{
    return lookupMultipartResolver();
}
org.springframework.web.multipart.support.MultipartFilter

public void setMultipartResolverBeanName(String multipartResolverBeanName)

{
    this.multipartResolverBeanName = multipartResolverBeanName;
}

MultipartResolutionDelegate

org.springframework.web.multipart.support.MultipartResolutionDelegate

public static final Object UNRESOLVABLE

org.springframework.web.multipart.support.MultipartResolutionDelegate

public static boolean isMultipartRequest(HttpServletRequest request)

{
    return (WebUtils.getNativeRequest(request, MultipartHttpServletRequest.class) != null || isMultipartContent(request));
}
org.springframework.web.multipart.support.MultipartResolutionDelegate

@Nullable public static Object resolveMultipartArgument(String name, MethodParameter parameter, HttpServletRequest request)

{
    MultipartHttpServletRequest multipartRequest = WebUtils.getNativeRequest(request, MultipartHttpServletRequest.class);
    boolean isMultipart = (multipartRequest != null || isMultipartContent(request));
    if (MultipartFile.class == parameter.getNestedParameterType()) {
        if (multipartRequest == null && isMultipart) {
            multipartRequest = new StandardMultipartHttpServletRequest(request);
        } 
        return (multipartRequest != null ? multipartRequest.getFile(name) : null);
    } else if (isMultipartFileCollection(parameter)) {
        if (multipartRequest == null && isMultipart) {
            multipartRequest = new StandardMultipartHttpServletRequest(request);
        } 
        return (multipartRequest != null ? multipartRequest.getFiles(name) : null);
    } else if (isMultipartFileArray(parameter)) {
        if (multipartRequest == null && isMultipart) {
            multipartRequest = new StandardMultipartHttpServletRequest(request);
        } 
        if (multipartRequest != null) {
            List<MultipartFile> multipartFiles = multipartRequest.getFiles(name);
            return multipartFiles.toArray(new MultipartFile[0]);
        } else {
            return null;
        }
    } else if (Part.class == parameter.getNestedParameterType()) {
        return (isMultipart ? request.getPart(name) : null);
    } else if (isPartCollection(parameter)) {
        return (isMultipart ? resolvePartList(request, name) : null);
    } else if (isPartArray(parameter)) {
        return (isMultipart ? resolvePartList(request, name).toArray(new Part[0]) : null);
    } else {
        return UNRESOLVABLE;
    }
}
org.springframework.web.multipart.support.MultipartResolutionDelegate

@Nullable public static MultipartRequest resolveMultipartRequest(NativeWebRequest webRequest)

{
    MultipartRequest multipartRequest = webRequest.getNativeRequest(MultipartRequest.class);
    if (multipartRequest != null) {
        return multipartRequest;
    } 
    HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
    if (servletRequest != null && isMultipartContent(servletRequest)) {
        return new StandardMultipartHttpServletRequest(servletRequest);
    } 
    return null;
}

RequestPartServletServerHttpRequest
extends ServletServerHttpRequest

org.springframework.web.multipart.support.RequestPartServletServerHttpRequest

public RequestPartServletServerHttpRequest RequestPartServletServerHttpRequest(HttpServletRequest request, String partName)

{
    super(request);
    this.multipartRequest = MultipartResolutionDelegate.asMultipartHttpServletRequest(request);
    this.partName = partName;
    HttpHeaders headers = this.multipartRequest.getMultipartHeaders(this.partName);
    if (headers == null) {
        throw new MissingServletRequestPartException(partName);
    } 
    this.headers = headers;
}
org.springframework.web.multipart.support.RequestPartServletServerHttpRequest

@Override public HttpHeaders getHeaders()

{
    return this.headers;
}

StandardMultipartHttpServletRequest
extends AbstractMultipartHttpServletRequest

org.springframework.web.multipart.support.StandardMultipartHttpServletRequest

public StandardMultipartHttpServletRequest StandardMultipartHttpServletRequest(HttpServletRequest request)

{
    this(request, false);
}
org.springframework.web.multipart.support.StandardMultipartHttpServletRequest

public StandardMultipartHttpServletRequest StandardMultipartHttpServletRequest(HttpServletRequest request, boolean lazyParsing)

{
    super(request);
    if (!lazyParsing) {
        parseRequest(request);
    } 
}
org.springframework.web.multipart.support.StandardMultipartHttpServletRequest

@Override public String getMultipartContentType(String paramOrFileName)

{
    try {
        Part part = getPart(paramOrFileName);
        return (part != null ? part.getContentType() : null);
    } catch (Throwable ex) {
        throw new MultipartException("Could not access multipart servlet request", ex);
    }
}
org.springframework.web.multipart.support.StandardMultipartHttpServletRequest

@Override public Map<String, String[]> getParameterMap()

{
    if (this.multipartParameterNames == null) {
        initializeMultipart();
    } 
    if (this.multipartParameterNames.isEmpty()) {
        return super.getParameterMap();
    } 
    Map<String, String[]> paramMap = new LinkedHashMap<>(super.getParameterMap());
    for (String paramName: this.multipartParameterNames) {
        if (!paramMap.containsKey(paramName)) {
            paramMap.put(paramName, getParameterValues(paramName));
        } 
    }
    return paramMap;
}
org.springframework.web.multipart.support.StandardMultipartHttpServletRequest

@Override public Enumeration<String> getParameterNames()

{
    if (this.multipartParameterNames == null) {
        initializeMultipart();
    } 
    if (this.multipartParameterNames.isEmpty()) {
        return super.getParameterNames();
    } 
    Set<String> paramNames = new LinkedHashSet<>();
    Enumeration<String> paramEnum = super.getParameterNames();
    while (paramEnum.hasMoreElements()) {
        paramNames.add(paramEnum.nextElement());
    }
    paramNames.addAll(this.multipartParameterNames);
    return Collections.enumeration(paramNames);
}
org.springframework.web.multipart.support.StandardMultipartHttpServletRequest

protected void handleParseFailure(Throwable ex)

{
    String msg = ex.getMessage();
    if (msg != null && msg.contains("size") && msg.contains("exceed")) {
        throw new MaxUploadSizeExceededException(-1, ex);
    } 
    throw new MultipartException("Failed to parse multipart servlet request", ex);
}
org.springframework.web.multipart.support.StandardMultipartHttpServletRequest

@Override protected void initializeMultipart()

{
    parseRequest(getRequest());
}

StandardServletMultipartResolver
implements MultipartResolver

org.springframework.web.multipart.support.StandardServletMultipartResolver

@Override public boolean isMultipart(HttpServletRequest request)

{
    return StringUtils.startsWithIgnoreCase(request.getContentType(), "multipart/");
}
org.springframework.web.multipart.support.StandardServletMultipartResolver

@Override public MultipartHttpServletRequest resolveMultipart(HttpServletRequest request)

{
    return new StandardMultipartHttpServletRequest(request, this.resolveLazily);
}
org.springframework.web.multipart.support.StandardServletMultipartResolver

public void setResolveLazily(boolean resolveLazily)

{
    this.resolveLazily = resolveLazily;
}

StringMultipartFileEditor
extends PropertyEditorSupport

org.springframework.web.multipart.support.StringMultipartFileEditor

public StringMultipartFileEditor StringMultipartFileEditor()

{
    this.charsetName = null;
}
org.springframework.web.multipart.support.StringMultipartFileEditor

public StringMultipartFileEditor StringMultipartFileEditor(String charsetName)

{
    this.charsetName = charsetName;
}
org.springframework.web.multipart.support.StringMultipartFileEditor

@Override public void setAsText(String text)

{
    setValue(text);
}



DefaultServerWebExchangeBuilder
implements ServerWebExchange.Builder

org.springframework.web.server.DefaultServerWebExchangeBuilder

@Override public ServerWebExchange build()

{
    return new MutativeDecorator(this.delegate, this.request, this.response, this.principalMono);
}
org.springframework.web.server.DefaultServerWebExchangeBuilder

@Override public ServerWebExchange.Builder principal(Mono<Principal> principalMono)

{
    this.principalMono = principalMono;
    return this;
}
org.springframework.web.server.DefaultServerWebExchangeBuilder

@Override public ServerWebExchange.Builder request(Consumer<ServerHttpRequest.Builder> consumer)

{
    ServerHttpRequest.Builder builder = this.delegate.getRequest().mutate();
    consumer.accept(builder);
    return request(builder.build());
}
org.springframework.web.server.DefaultServerWebExchangeBuilder

@Override public ServerWebExchange.Builder request(ServerHttpRequest request)

{
    this.request = request;
    return this;
}
org.springframework.web.server.DefaultServerWebExchangeBuilder

@Override public ServerWebExchange.Builder response(ServerHttpResponse response)

{
    this.response = response;
    return this;
}

MediaTypeNotSupportedStatusException
extends ResponseStatusException

org.springframework.web.server.MediaTypeNotSupportedStatusException

public MediaTypeNotSupportedStatusException MediaTypeNotSupportedStatusException(String reason)

{
    super(HttpStatus.UNSUPPORTED_MEDIA_TYPE, reason);
    this.supportedMediaTypes = Collections.emptyList();
}
org.springframework.web.server.MediaTypeNotSupportedStatusException

public MediaTypeNotSupportedStatusException MediaTypeNotSupportedStatusException(List<MediaType> supportedMediaTypes)

{
    super(HttpStatus.UNSUPPORTED_MEDIA_TYPE, "Unsupported media type", null);
    this.supportedMediaTypes = Collections.unmodifiableList(supportedMediaTypes);
}
org.springframework.web.server.MediaTypeNotSupportedStatusException

public List<MediaType> getSupportedMediaTypes()

{
    return this.supportedMediaTypes;
}

MethodNotAllowedException
extends ResponseStatusException

org.springframework.web.server.MethodNotAllowedException

public MethodNotAllowedException MethodNotAllowedException(HttpMethod method, Collection<HttpMethod> supportedMethods)

{
    this(method.name(), supportedMethods);
}
org.springframework.web.server.MethodNotAllowedException

public MethodNotAllowedException MethodNotAllowedException(String method, @Nullable Collection<HttpMethod> supportedMethods)

{
    super(HttpStatus.METHOD_NOT_ALLOWED, "Request method '" + method + "' not supported");
    Assert.notNull(method, "'method' is required");
    if (supportedMethods == null) {
        supportedMethods = Collections.emptySet();
    } 
    this.method = method;
    this.supportedMethods = Collections.unmodifiableSet(new HashSet<>(supportedMethods));
}
org.springframework.web.server.MethodNotAllowedException

public String getHttpMethod()

{
    return this.method;
}
org.springframework.web.server.MethodNotAllowedException

public Set<HttpMethod> getSupportedMethods()

{
    return this.supportedMethods;
}

NotAcceptableStatusException
extends ResponseStatusException

org.springframework.web.server.NotAcceptableStatusException

public NotAcceptableStatusException NotAcceptableStatusException(String reason)

{
    super(HttpStatus.NOT_ACCEPTABLE, reason);
    this.supportedMediaTypes = Collections.emptyList();
}
org.springframework.web.server.NotAcceptableStatusException

public NotAcceptableStatusException NotAcceptableStatusException(List<MediaType> supportedMediaTypes)

{
    super(HttpStatus.NOT_ACCEPTABLE, "Could not find acceptable representation");
    this.supportedMediaTypes = Collections.unmodifiableList(supportedMediaTypes);
}
org.springframework.web.server.NotAcceptableStatusException

public List<MediaType> getSupportedMediaTypes()

{
    return this.supportedMediaTypes;
}

ResponseStatusException
extends NestedRuntimeException

org.springframework.web.server.ResponseStatusException

public ResponseStatusException ResponseStatusException(HttpStatus status)

{
    this(status, null, null);
}
org.springframework.web.server.ResponseStatusException

public ResponseStatusException ResponseStatusException(HttpStatus status, @Nullable String reason)

{
    this(status, reason, null);
}
org.springframework.web.server.ResponseStatusException

public ResponseStatusException ResponseStatusException(HttpStatus status, @Nullable String reason, @Nullable Throwable cause)

{
    super(null, cause);
    Assert.notNull(status, "HttpStatus is required");
    this.status = status;
    this.reason = reason;
}
org.springframework.web.server.ResponseStatusException

@Nullable public String getReason()

{
    return this.reason;
}
org.springframework.web.server.ResponseStatusException

public HttpStatus getStatus()

{
    return this.status;
}

ServerErrorException
extends ResponseStatusException

org.springframework.web.server.ServerErrorException

public ServerErrorException ServerErrorException(String reason, @Nullable Throwable cause)

{
    super(HttpStatus.INTERNAL_SERVER_ERROR, reason, cause);
    this.handlerMethod = null;
    this.parameter = null;
}
org.springframework.web.server.ServerErrorException

public ServerErrorException ServerErrorException(String reason, Method handlerMethod, @Nullable Throwable cause)

{
    super(HttpStatus.INTERNAL_SERVER_ERROR, reason, cause);
    this.handlerMethod = handlerMethod;
    this.parameter = null;
}
org.springframework.web.server.ServerErrorException

public ServerErrorException ServerErrorException(String reason, MethodParameter parameter, @Nullable Throwable cause)

{
    super(HttpStatus.INTERNAL_SERVER_ERROR, reason, cause);
    this.handlerMethod = parameter.getMethod();
    this.parameter = parameter;
}
org.springframework.web.server.ServerErrorException

@Deprecated public ServerErrorException ServerErrorException(String reason, MethodParameter parameter)

{
    this(reason, parameter, null);
}
org.springframework.web.server.ServerErrorException

@Deprecated public ServerErrorException ServerErrorException(String reason)

{
    super(HttpStatus.INTERNAL_SERVER_ERROR, reason, null);
    this.handlerMethod = null;
    this.parameter = null;
}
org.springframework.web.server.ServerErrorException

@Nullable public Method getHandlerMethod()

{
    return this.handlerMethod;
}
org.springframework.web.server.ServerErrorException

@Nullable public MethodParameter getMethodParameter()

{
    return this.parameter;
}

ServerWebExchange

ServerWebExchangeDecorator
implements ServerWebExchange

org.springframework.web.server.ServerWebExchangeDecorator

protected ServerWebExchangeDecorator ServerWebExchangeDecorator(ServerWebExchange delegate)

{
    Assert.notNull(delegate, "ServerWebExchange 'delegate' is required.");
    this.delegate = delegate;
}
org.springframework.web.server.ServerWebExchangeDecorator

@Override public void addUrlTransformer(Function<String, String> transformer)

{
    getDelegate().addUrlTransformer(transformer);
}
org.springframework.web.server.ServerWebExchangeDecorator

@Override public boolean checkNotModified(Instant lastModified)

{
    return getDelegate().checkNotModified(lastModified);
}
org.springframework.web.server.ServerWebExchangeDecorator

@Override public boolean checkNotModified(String etag)

{
    return getDelegate().checkNotModified(etag);
}
org.springframework.web.server.ServerWebExchangeDecorator

@Override public boolean checkNotModified(@Nullable String etag, Instant lastModified)

{
    return getDelegate().checkNotModified(etag, lastModified);
}
org.springframework.web.server.ServerWebExchangeDecorator

@Override public ApplicationContext getApplicationContext()

{
    return getDelegate().getApplicationContext();
}
org.springframework.web.server.ServerWebExchangeDecorator

@Override public Map<String, Object> getAttributes()

{
    return getDelegate().getAttributes();
}
org.springframework.web.server.ServerWebExchangeDecorator

public ServerWebExchange getDelegate()

{
    return this.delegate;
}
org.springframework.web.server.ServerWebExchangeDecorator

@Override public Mono<MultiValueMap<String, String>> getFormData()

{
    return getDelegate().getFormData();
}
org.springframework.web.server.ServerWebExchangeDecorator

@Override public LocaleContext getLocaleContext()

{
    return getDelegate().getLocaleContext();
}
org.springframework.web.server.ServerWebExchangeDecorator

@Override public String getLogPrefix()

{
    return getDelegate().getLogPrefix();
}
org.springframework.web.server.ServerWebExchangeDecorator

@Override public Mono<MultiValueMap<String, Part>> getMultipartData()

{
    return getDelegate().getMultipartData();
}
org.springframework.web.server.ServerWebExchangeDecorator

<T>@Override public Mono<T> getPrincipal()

{
    return getDelegate().getPrincipal();
}
org.springframework.web.server.ServerWebExchangeDecorator

@Override public ServerHttpRequest getRequest()

{
    return getDelegate().getRequest();
}
org.springframework.web.server.ServerWebExchangeDecorator

@Override public ServerHttpResponse getResponse()

{
    return getDelegate().getResponse();
}
org.springframework.web.server.ServerWebExchangeDecorator

@Override public Mono<WebSession> getSession()

{
    return getDelegate().getSession();
}
org.springframework.web.server.ServerWebExchangeDecorator

@Override public boolean isNotModified()

{
    return getDelegate().isNotModified();
}
org.springframework.web.server.ServerWebExchangeDecorator

@Override public String toString()

{
    return getClass().getSimpleName() + " [delegate=" + getDelegate() + "]";
}
org.springframework.web.server.ServerWebExchangeDecorator

@Override public String transformUrl(String url)

{
    return getDelegate().transformUrl(url);
}

ServerWebInputException
extends ResponseStatusException

org.springframework.web.server.ServerWebInputException

public ServerWebInputException ServerWebInputException(String reason)

{
    this(reason, null, null);
}
org.springframework.web.server.ServerWebInputException

public ServerWebInputException ServerWebInputException(String reason, @Nullable MethodParameter parameter)

{
    this(reason, parameter, null);
}
org.springframework.web.server.ServerWebInputException

public ServerWebInputException ServerWebInputException(String reason, @Nullable MethodParameter parameter, @Nullable Throwable cause)

{
    super(HttpStatus.BAD_REQUEST, reason, cause);
    this.parameter = parameter;
}
org.springframework.web.server.ServerWebInputException

@Nullable public MethodParameter getMethodParameter()

{
    return this.parameter;
}

UnsupportedMediaTypeStatusException
extends ResponseStatusException

org.springframework.web.server.UnsupportedMediaTypeStatusException

public UnsupportedMediaTypeStatusException UnsupportedMediaTypeStatusException(@Nullable String reason)

{
    super(HttpStatus.UNSUPPORTED_MEDIA_TYPE, reason);
    this.contentType = null;
    this.supportedMediaTypes = Collections.emptyList();
    this.bodyType = null;
}
org.springframework.web.server.UnsupportedMediaTypeStatusException

public UnsupportedMediaTypeStatusException UnsupportedMediaTypeStatusException(@Nullable MediaType contentType, List<MediaType> supportedTypes)

{
    this(contentType, supportedTypes, null);
}
org.springframework.web.server.UnsupportedMediaTypeStatusException

public UnsupportedMediaTypeStatusException UnsupportedMediaTypeStatusException(@Nullable MediaType contentType, List<MediaType> supportedTypes, @Nullable ResolvableType bodyType)

{
    super(HttpStatus.UNSUPPORTED_MEDIA_TYPE, initReason(contentType, bodyType));
    this.contentType = contentType;
    this.supportedMediaTypes = Collections.unmodifiableList(supportedTypes);
    this.bodyType = bodyType;
}
org.springframework.web.server.UnsupportedMediaTypeStatusException

@Nullable public ResolvableType getBodyType()

{
    return this.bodyType;
}
org.springframework.web.server.UnsupportedMediaTypeStatusException

@Nullable public MediaType getContentType()

{
    return this.contentType;
}
org.springframework.web.server.UnsupportedMediaTypeStatusException

public List<MediaType> getSupportedMediaTypes()

{
    return this.supportedMediaTypes;
}

WebExceptionHandler

WebFilter

WebFilterChain

WebHandler

WebSession

AbstractReactiveWebInitializer
implements WebApplicationInitializer

org.springframework.web.server.adapter.AbstractReactiveWebInitializer

public static final String DEFAULT_SERVLET_NAME

org.springframework.web.server.adapter.AbstractReactiveWebInitializer

protected abstract Class<?>[] getConfigClasses()

org.springframework.web.server.adapter.AbstractReactiveWebInitializer

protected String getServletMapping()

{
    return "/";
}
org.springframework.web.server.adapter.AbstractReactiveWebInitializer

protected String getServletName()

{
    return DEFAULT_SERVLET_NAME;
}
org.springframework.web.server.adapter.AbstractReactiveWebInitializer

protected void refreshApplicationContext(ApplicationContext context)

{
    if (context instanceof ConfigurableApplicationContext) {
        ConfigurableApplicationContext cac = (ConfigurableApplicationContext)context;
        if (!cac.isActive()) {
            cac.refresh();
        } 
    } 
}

DefaultServerWebExchange
implements ServerWebExchange

org.springframework.web.server.adapter.DefaultServerWebExchange

public DefaultServerWebExchange DefaultServerWebExchange(ServerHttpRequest request, ServerHttpResponse response, WebSessionManager sessionManager, ServerCodecConfigurer codecConfigurer, LocaleContextResolver localeContextResolver)

{
    this(request, response, sessionManager, codecConfigurer, localeContextResolver, null);
}
org.springframework.web.server.adapter.DefaultServerWebExchange

@Override public void addUrlTransformer(Function<String, String> transformer)

{
    Assert.notNull(transformer, "'encoder' must not be null");
    this.urlTransformer = this.urlTransformer.andThen(transformer);
}
org.springframework.web.server.adapter.DefaultServerWebExchange

@Override public boolean checkNotModified(Instant lastModified)

{
    return checkNotModified(null, lastModified);
}
org.springframework.web.server.adapter.DefaultServerWebExchange

@Override public boolean checkNotModified(String etag)

{
    return checkNotModified(etag, Instant.MIN);
}
org.springframework.web.server.adapter.DefaultServerWebExchange

@Override public boolean checkNotModified(@Nullable String etag, Instant lastModified)

{
    HttpStatus status = getResponse().getStatusCode();
    if (this.notModified || (status != null && !HttpStatus.OK.equals(status))) {
        return this.notModified;
    } 
    if (validateIfUnmodifiedSince(lastModified)) {
        if (this.notModified) {
            getResponse().setStatusCode(HttpStatus.PRECONDITION_FAILED);
        } 
        return this.notModified;
    } 
    boolean validated = validateIfNoneMatch(etag);
    if (!validated) {
        validateIfModifiedSince(lastModified);
    } 
    boolean isHttpGetOrHead = SAFE_METHODS.contains(getRequest().getMethod());
    if (this.notModified) {
        getResponse().setStatusCode(isHttpGetOrHead ? HttpStatus.NOT_MODIFIED : HttpStatus.PRECONDITION_FAILED);
    } 
    if (isHttpGetOrHead) {
        if (lastModified.isAfter(Instant.EPOCH) && getResponseHeaders().getLastModified() == -1) {
            getResponseHeaders().setLastModified(lastModified.toEpochMilli());
        } 
        if (StringUtils.hasLength(etag) && getResponseHeaders().getETag() == null) {
            getResponseHeaders().setETag(padEtagIfNecessary(etag));
        } 
    } 
    return this.notModified;
}
org.springframework.web.server.adapter.DefaultServerWebExchange

@Override @Nullable public ApplicationContext getApplicationContext()

{
    return this.applicationContext;
}
org.springframework.web.server.adapter.DefaultServerWebExchange

@Override public Map<String, Object> getAttributes()

{
    return this.attributes;
}
org.springframework.web.server.adapter.DefaultServerWebExchange

@Override public Mono<MultiValueMap<String, String>> getFormData()

{
    return this.formDataMono;
}
org.springframework.web.server.adapter.DefaultServerWebExchange

@Override public LocaleContext getLocaleContext()

{
    return this.localeContextResolver.resolveLocaleContext(this);
}
org.springframework.web.server.adapter.DefaultServerWebExchange

@Override public String getLogPrefix()

{
    Object value = getAttribute(LOG_ID_ATTRIBUTE);
    if (this.logId != value) {
        this.logId = value;
        this.logPrefix = value != null ? "[" + value + "] " : "";
    } 
    return this.logPrefix;
}
org.springframework.web.server.adapter.DefaultServerWebExchange

@Override public Mono<MultiValueMap<String, Part>> getMultipartData()

{
    return this.multipartDataMono;
}
org.springframework.web.server.adapter.DefaultServerWebExchange

<T>@Override public Mono<T> getPrincipal()

{
    return Mono.empty();
}
org.springframework.web.server.adapter.DefaultServerWebExchange

@Override public ServerHttpRequest getRequest()

{
    return this.request;
}
org.springframework.web.server.adapter.DefaultServerWebExchange

@Override public ServerHttpResponse getResponse()

{
    return this.response;
}
org.springframework.web.server.adapter.DefaultServerWebExchange

@Override public Mono<WebSession> getSession()

{
    return this.sessionMono;
}
org.springframework.web.server.adapter.DefaultServerWebExchange

@Override public boolean isNotModified()

{
    return this.notModified;
}
org.springframework.web.server.adapter.DefaultServerWebExchange

volatile boolean notModified

org.springframework.web.server.adapter.DefaultServerWebExchange

@Override public String transformUrl(String url)

{
    return this.urlTransformer.apply(url);
}

ForwardedHeaderTransformer
implements Function<ServerHttpRequest, ServerHttpRequest>

org.springframework.web.server.adapter.ForwardedHeaderTransformer

protected boolean hasForwardedHeaders(ServerHttpRequest request)

{
    HttpHeaders headers = request.getHeaders();
    for (String headerName: FORWARDED_HEADER_NAMES) {
        if (headers.containsKey(headerName)) {
            return true;
        } 
    }
    return false;
}
org.springframework.web.server.adapter.ForwardedHeaderTransformer

public boolean isRemoveOnly()

{
    return this.removeOnly;
}
org.springframework.web.server.adapter.ForwardedHeaderTransformer

public void setRemoveOnly(boolean removeOnly)

{
    this.removeOnly = removeOnly;
}

HttpWebHandlerAdapter
extends WebHandlerDecorator implements HttpHandler

org.springframework.web.server.adapter.HttpWebHandlerAdapter

public HttpWebHandlerAdapter HttpWebHandlerAdapter(WebHandler delegate)

{
    super(delegate);
}
org.springframework.web.server.adapter.HttpWebHandlerAdapter

protected ServerWebExchange createExchange(ServerHttpRequest request, ServerHttpResponse response)

{
    return new DefaultServerWebExchange(request, response, this.sessionManager, getCodecConfigurer(), getLocaleContextResolver(), this.applicationContext);
}
org.springframework.web.server.adapter.HttpWebHandlerAdapter

@Nullable public ApplicationContext getApplicationContext()

{
    return this.applicationContext;
}
org.springframework.web.server.adapter.HttpWebHandlerAdapter

public ServerCodecConfigurer getCodecConfigurer()

{
    return this.codecConfigurer;
}
org.springframework.web.server.adapter.HttpWebHandlerAdapter

@Nullable public ForwardedHeaderTransformer getForwardedHeaderTransformer()

{
    return this.forwardedHeaderTransformer;
}
org.springframework.web.server.adapter.HttpWebHandlerAdapter

public LocaleContextResolver getLocaleContextResolver()

{
    return this.localeContextResolver;
}
org.springframework.web.server.adapter.HttpWebHandlerAdapter

public WebSessionManager getSessionManager()

{
    return this.sessionManager;
}
org.springframework.web.server.adapter.HttpWebHandlerAdapter

@Override public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response)

{
    if (this.forwardedHeaderTransformer != null) {
        request = this.forwardedHeaderTransformer.apply(request);
    } 
    ServerWebExchange exchange = createExchange(request, response);
    LogFormatUtils.traceDebug(logger, traceOn -> exchange.getLogPrefix() + formatRequest(exchange.getRequest()) + (traceOn ? ", headers=" + formatHeaders(exchange.getRequest().getHeaders()) : ""));
    return getDelegate().handle(exchange).doOnSuccess(aVoid -> logResponse(exchange)).onErrorResume(ex -> handleUnresolvedError(exchange, ex)).then(Mono.defer(response::setComplete));
}
org.springframework.web.server.adapter.HttpWebHandlerAdapter

public void setApplicationContext(ApplicationContext applicationContext)

{
    this.applicationContext = applicationContext;
}
org.springframework.web.server.adapter.HttpWebHandlerAdapter

public void setForwardedHeaderTransformer(ForwardedHeaderTransformer transformer)

{
    Assert.notNull(transformer, "ForwardedHeaderTransformer is required");
    this.forwardedHeaderTransformer = transformer;
}
org.springframework.web.server.adapter.HttpWebHandlerAdapter

public void setLocaleContextResolver(LocaleContextResolver resolver)

{
    Assert.notNull(resolver, "LocaleContextResolver is required");
    this.localeContextResolver = resolver;
}
org.springframework.web.server.adapter.HttpWebHandlerAdapter

public void setSessionManager(WebSessionManager sessionManager)

{
    Assert.notNull(sessionManager, "WebSessionManager must not be null");
    this.sessionManager = sessionManager;
}

WebHttpHandlerBuilder

org.springframework.web.server.adapter.WebHttpHandlerBuilder

public static final String FORWARDED_HEADER_TRANSFORMER_BEAN_NAME

org.springframework.web.server.adapter.WebHttpHandlerBuilder

public static final String LOCALE_CONTEXT_RESOLVER_BEAN_NAME

org.springframework.web.server.adapter.WebHttpHandlerBuilder

public static final String SERVER_CODEC_CONFIGURER_BEAN_NAME

org.springframework.web.server.adapter.WebHttpHandlerBuilder

public static final String WEB_HANDLER_BEAN_NAME

org.springframework.web.server.adapter.WebHttpHandlerBuilder

public static final String WEB_SESSION_MANAGER_BEAN_NAME

org.springframework.web.server.adapter.WebHttpHandlerBuilder

@Override public WebHttpHandlerBuilder clone()

{
    return new WebHttpHandlerBuilder(this);
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder

public WebHttpHandlerBuilder codecConfigurer(ServerCodecConfigurer codecConfigurer)

{
    this.codecConfigurer = codecConfigurer;
    return this;
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder

public WebHttpHandlerBuilder exceptionHandler(WebExceptionHandler... handlers)

{
    if (!ObjectUtils.isEmpty(handlers)) {
        this.exceptionHandlers.addAll(Arrays.asList(handlers));
    } 
    return this;
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder

public WebHttpHandlerBuilder exceptionHandlers(Consumer<List<WebExceptionHandler>> consumer)

{
    consumer.accept(this.exceptionHandlers);
    return this;
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder

public WebHttpHandlerBuilder filter(WebFilter... filters)

{
    if (!ObjectUtils.isEmpty(filters)) {
        this.filters.addAll(Arrays.asList(filters));
        updateFilters();
    } 
    return this;
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder

public WebHttpHandlerBuilder filters(Consumer<List<WebFilter>> consumer)

{
    consumer.accept(this.filters);
    updateFilters();
    return this;
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder

public WebHttpHandlerBuilder forwardedHeaderTransformer(ForwardedHeaderTransformer transformer)

{
    this.forwardedHeaderTransformer = transformer;
    return this;
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder

public boolean hasCodecConfigurer()

{
    return (this.codecConfigurer != null);
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder

public boolean hasForwardedHeaderTransformer()

{
    return (this.forwardedHeaderTransformer != null);
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder

public boolean hasLocaleContextResolver()

{
    return (this.localeContextResolver != null);
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder

public boolean hasSessionManager()

{
    return (this.sessionManager != null);
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder

public WebHttpHandlerBuilder localeContextResolver(LocaleContextResolver localeContextResolver)

{
    this.localeContextResolver = localeContextResolver;
    return this;
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder

public WebHttpHandlerBuilder sessionManager(WebSessionManager manager)

{
    this.sessionManager = manager;
    return this;
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder

public static WebHttpHandlerBuilder webHandler(WebHandler webHandler)

{
    return new WebHttpHandlerBuilder(webHandler, null);
}


DefaultWebFilterChain
implements WebFilterChain

org.springframework.web.server.handler.DefaultWebFilterChain

@Deprecated public DefaultWebFilterChain DefaultWebFilterChain(WebHandler handler, WebFilter... filters)

{
    this(handler, Arrays.asList(filters));
}
org.springframework.web.server.handler.DefaultWebFilterChain

@Override public Mono<Void> filter(ServerWebExchange exchange)

{
    return Mono.defer(() -> this.currentFilter != null && this.chain != null ? invokeFilter(this.currentFilter, this.chain, exchange) : this.handler.handle(exchange));
}
org.springframework.web.server.handler.DefaultWebFilterChain

public List<WebFilter> getFilters()

{
    return this.allFilters;
}
org.springframework.web.server.handler.DefaultWebFilterChain

public WebHandler getHandler()

{
    return this.handler;
}

ExceptionHandlingWebHandler
extends WebHandlerDecorator

org.springframework.web.server.handler.ExceptionHandlingWebHandler

public ExceptionHandlingWebHandler ExceptionHandlingWebHandler(WebHandler delegate, List<WebExceptionHandler> handlers)

{
    super(delegate);
    List<WebExceptionHandler> handlersToUse = new ArrayList<>();
    handlersToUse.add(new CheckpointInsertingHandler());
    handlersToUse.addAll(handlers);
    this.exceptionHandlers = Collections.unmodifiableList(handlersToUse);
}
org.springframework.web.server.handler.ExceptionHandlingWebHandler

public List<WebExceptionHandler> getExceptionHandlers()

{
    return this.exceptionHandlers;
}
org.springframework.web.server.handler.ExceptionHandlingWebHandler

@Override public Mono<Void> handle(ServerWebExchange exchange)

{
    Mono < Void > completion;
    try {
        completion = super.handle(exchange);
    } catch (Throwable ex) {
        completion = Mono.error(ex);
    }
    for (WebExceptionHandler handler: this.exceptionHandlers) {
        completion = completion.onErrorResume(ex -> handler.handle(exchange, ex));
    }
    return completion;
}

FilteringWebHandler
extends WebHandlerDecorator

org.springframework.web.server.handler.FilteringWebHandler

public FilteringWebHandler FilteringWebHandler(WebHandler handler, List<WebFilter> filters)

{
    super(handler);
    this.chain = new DefaultWebFilterChain(handler, filters);
}
org.springframework.web.server.handler.FilteringWebHandler

public List<WebFilter> getFilters()

{
    return this.chain.getFilters();
}
org.springframework.web.server.handler.FilteringWebHandler

@Override public Mono<Void> handle(ServerWebExchange exchange)

{
    return this.chain.filter(exchange);
}

ResponseStatusExceptionHandler
implements WebExceptionHandler

org.springframework.web.server.handler.ResponseStatusExceptionHandler

@Nullable protected HttpStatus determineStatus(Throwable ex)

{
    if (ex instanceof ResponseStatusException) {
        return ((ResponseStatusException)ex).getStatus();
    } 
    return null;
}
org.springframework.web.server.handler.ResponseStatusExceptionHandler

@Override public Mono<Void> handle(ServerWebExchange exchange, Throwable ex)

{
    HttpStatus status = resolveStatus(ex);
    if (status == null || !exchange.getResponse().setStatusCode(status)) {
        return Mono.error(ex);
    } 
    String logPrefix = exchange.getLogPrefix();
    if (this.warnLogger != null && this.warnLogger.isWarnEnabled()) {
        this.warnLogger.warn(logPrefix + formatError(ex, exchange.getRequest()), ex);
    } else if (logger.isDebugEnabled()) {
        logger.debug(logPrefix + formatError(ex, exchange.getRequest()));
    } 
    return exchange.getResponse().setComplete();
}
org.springframework.web.server.handler.ResponseStatusExceptionHandler

public void setWarnLogCategory(String loggerName)

{
    this.warnLogger = LogFactory.getLog(loggerName);
}

WebHandlerDecorator
implements WebHandler

org.springframework.web.server.handler.WebHandlerDecorator

public WebHandlerDecorator WebHandlerDecorator(WebHandler delegate)

{
    Assert.notNull(delegate, "'delegate' must not be null");
    this.delegate = delegate;
}
org.springframework.web.server.handler.WebHandlerDecorator

public WebHandler getDelegate()

{
    return this.delegate;
}
org.springframework.web.server.handler.WebHandlerDecorator

@Override public Mono<Void> handle(ServerWebExchange exchange)

{
    return this.delegate.handle(exchange);
}
org.springframework.web.server.handler.WebHandlerDecorator

@Override public String toString()

{
    return getClass().getSimpleName() + " [delegate=" + this.delegate + "]";
}


AcceptHeaderLocaleContextResolver
implements LocaleContextResolver

org.springframework.web.server.i18n.AcceptHeaderLocaleContextResolver

@Nullable public Locale getDefaultLocale()

{
    return this.defaultLocale;
}
org.springframework.web.server.i18n.AcceptHeaderLocaleContextResolver

public List<Locale> getSupportedLocales()

{
    return this.supportedLocales;
}
org.springframework.web.server.i18n.AcceptHeaderLocaleContextResolver

@Override public LocaleContext resolveLocaleContext(ServerWebExchange exchange)

{
    List<Locale> requestLocales = null;
    try {
        requestLocales = exchange.getRequest().getHeaders().getAcceptLanguageAsLocales();
    } catch (IllegalArgumentException ex) {
    }
    return new SimpleLocaleContext(resolveSupportedLocale(requestLocales));
}
org.springframework.web.server.i18n.AcceptHeaderLocaleContextResolver

public void setDefaultLocale(@Nullable Locale defaultLocale)

{
    this.defaultLocale = defaultLocale;
}
org.springframework.web.server.i18n.AcceptHeaderLocaleContextResolver

@Override public void setLocaleContext(ServerWebExchange exchange, @Nullable LocaleContext locale)

{
    throw new UnsupportedOperationException("Cannot change HTTP accept header - use a different locale context resolution strategy");
}
org.springframework.web.server.i18n.AcceptHeaderLocaleContextResolver

public void setSupportedLocales(List<Locale> locales)

{
    this.supportedLocales.clear();
    this.supportedLocales.addAll(locales);
}

FixedLocaleContextResolver
implements LocaleContextResolver

org.springframework.web.server.i18n.FixedLocaleContextResolver

public FixedLocaleContextResolver FixedLocaleContextResolver()

{
    this(Locale.getDefault());
}
org.springframework.web.server.i18n.FixedLocaleContextResolver

public FixedLocaleContextResolver FixedLocaleContextResolver(Locale locale)

{
    this(locale, null);
}
org.springframework.web.server.i18n.FixedLocaleContextResolver

public FixedLocaleContextResolver FixedLocaleContextResolver(Locale locale, @Nullable TimeZone timeZone)

{
    Assert.notNull(locale, "Locale must not be null");
    this.locale = locale;
    this.timeZone = timeZone;
}
org.springframework.web.server.i18n.FixedLocaleContextResolver

@Override public LocaleContext resolveLocaleContext(ServerWebExchange exchange)

{
    return new TimeZoneAwareLocaleContext() {
        @Override
        public Locale getLocale() {
            return locale;
        }
        @Override
        @Nullable
        public TimeZone getTimeZone() {
            return timeZone;
        }
    };
}
org.springframework.web.server.i18n.FixedLocaleContextResolver

@Override public void setLocaleContext(ServerWebExchange exchange, @Nullable LocaleContext localeContext)

{
    throw new UnsupportedOperationException("Cannot change fixed locale - use a different locale context resolution strategy");
}

LocaleContextResolver



CookieWebSessionIdResolver
implements WebSessionIdResolver

org.springframework.web.server.session.CookieWebSessionIdResolver

public void addCookieInitializer(Consumer<ResponseCookie.ResponseCookieBuilder> initializer)

{
    this.cookieInitializer = this.cookieInitializer != null ? this.cookieInitializer.andThen(initializer) : initializer;
}
org.springframework.web.server.session.CookieWebSessionIdResolver

@Override public void expireSession(ServerWebExchange exchange)

{
    ResponseCookie cookie = initSessionCookie(exchange, "", Duration.ZERO);
    exchange.getResponse().getCookies().set(this.cookieName, cookie);
}
org.springframework.web.server.session.CookieWebSessionIdResolver

public Duration getCookieMaxAge()

{
    return this.cookieMaxAge;
}
org.springframework.web.server.session.CookieWebSessionIdResolver

public String getCookieName()

{
    return this.cookieName;
}
org.springframework.web.server.session.CookieWebSessionIdResolver

@Override public List<String> resolveSessionIds(ServerWebExchange exchange)

{
    MultiValueMap<String, HttpCookie> cookieMap = exchange.getRequest().getCookies();
    List<HttpCookie> cookies = cookieMap.get(getCookieName());
    if (cookies == null) {
        return Collections.emptyList();
    } 
    return cookies.stream().map(HttpCookie::getValue).collect(Collectors.toList());
}
org.springframework.web.server.session.CookieWebSessionIdResolver

public void setCookieMaxAge(Duration maxAge)

{
    this.cookieMaxAge = maxAge;
}
org.springframework.web.server.session.CookieWebSessionIdResolver

public void setCookieName(String cookieName)

{
    Assert.hasText(cookieName, "'cookieName' must not be empty");
    this.cookieName = cookieName;
}
org.springframework.web.server.session.CookieWebSessionIdResolver

@Override public void setSessionId(ServerWebExchange exchange, String id)

{
    Assert.notNull(id, "'id' is required");
    ResponseCookie cookie = initSessionCookie(exchange, id, getCookieMaxAge());
    exchange.getResponse().getCookies().set(this.cookieName, cookie);
}

DefaultWebSessionManager
implements WebSessionManager

org.springframework.web.server.session.DefaultWebSessionManager

@Override public Mono<WebSession> getSession(ServerWebExchange exchange)

{
    return Mono.defer(() -> retrieveSession(exchange).switchIfEmpty(this.sessionStore.createWebSession()).doOnNext(session -> exchange.getResponse().beforeCommit(() -> save(exchange, session))));
}
org.springframework.web.server.session.DefaultWebSessionManager

public WebSessionIdResolver getSessionIdResolver()

{
    return this.sessionIdResolver;
}
org.springframework.web.server.session.DefaultWebSessionManager

public WebSessionStore getSessionStore()

{
    return this.sessionStore;
}
org.springframework.web.server.session.DefaultWebSessionManager

public void setSessionIdResolver(WebSessionIdResolver sessionIdResolver)

{
    Assert.notNull(sessionIdResolver, "WebSessionIdResolver is required");
    this.sessionIdResolver = sessionIdResolver;
}
org.springframework.web.server.session.DefaultWebSessionManager

public void setSessionStore(WebSessionStore sessionStore)

{
    Assert.notNull(sessionStore, "WebSessionStore is required");
    this.sessionStore = sessionStore;
}

HeaderWebSessionIdResolver
implements WebSessionIdResolver

org.springframework.web.server.session.HeaderWebSessionIdResolver

public static final String DEFAULT_HEADER_NAME

org.springframework.web.server.session.HeaderWebSessionIdResolver

@Override public void expireSession(ServerWebExchange exchange)

{
    this.setSessionId(exchange, "");
}
org.springframework.web.server.session.HeaderWebSessionIdResolver

public String getHeaderName()

{
    return this.headerName;
}
org.springframework.web.server.session.HeaderWebSessionIdResolver

@Override public List<String> resolveSessionIds(ServerWebExchange exchange)

{
    HttpHeaders headers = exchange.getRequest().getHeaders();
    return headers.getOrDefault(getHeaderName(), Collections.emptyList());
}
org.springframework.web.server.session.HeaderWebSessionIdResolver

public void setHeaderName(String headerName)

{
    Assert.hasText(headerName, "'headerName' must not be empty");
    this.headerName = headerName;
}
org.springframework.web.server.session.HeaderWebSessionIdResolver

@Override public void setSessionId(ServerWebExchange exchange, String id)

{
    Assert.notNull(id, "'id' is required.");
    exchange.getResponse().getHeaders().set(getHeaderName(), id);
}

InMemoryWebSessionStore
implements WebSessionStore

org.springframework.web.server.session.InMemoryWebSessionStore

@Override public Mono<WebSession> createWebSession()

{
    Instant now = this.clock.instant();
    this.expiredSessionChecker.checkIfNecessary(now);
    return Mono.fromSupplier(() -> new InMemoryWebSession(now));
}
org.springframework.web.server.session.InMemoryWebSessionStore

public Clock getClock()

{
    return this.clock;
}
org.springframework.web.server.session.InMemoryWebSessionStore

public int getMaxSessions()

{
    return this.maxSessions;
}
org.springframework.web.server.session.InMemoryWebSessionStore

public Map<String, WebSession> getSessions()

{
    return Collections.unmodifiableMap(this.sessions);
}
org.springframework.web.server.session.InMemoryWebSessionStore

public void removeExpiredSessions()

{
    this.expiredSessionChecker.removeExpiredSessions(this.clock.instant());
}
org.springframework.web.server.session.InMemoryWebSessionStore

@Override public Mono<Void> removeSession(String id)

{
    this.sessions.remove(id);
    return Mono.empty();
}
org.springframework.web.server.session.InMemoryWebSessionStore

public void setClock(Clock clock)

{
    Assert.notNull(clock, "Clock is required");
    this.clock = clock;
    removeExpiredSessions();
}
org.springframework.web.server.session.InMemoryWebSessionStore

public void setMaxSessions(int maxSessions)

{
    this.maxSessions = maxSessions;
}
org.springframework.web.server.session.InMemoryWebSessionStore

@Override public Mono<WebSession> updateLastAccessTime(WebSession session)

{
    return Mono.fromSupplier(() -> {
        Assert.isInstanceOf(InMemoryWebSession.class, session);
        ((InMemoryWebSession)session).updateLastAccessTime(this.clock.instant());
        return session;
    });
}

WebSessionIdResolver

WebSessionManager

WebSessionStore


AbstractUriTemplateHandler
implements UriTemplateHandler

org.springframework.web.util.AbstractUriTemplateHandler

@Override public URI expand(String uriTemplate, Map<String, ?> uriVariables)

{
    if (!getDefaultUriVariables().isEmpty()) {
        Map<String, Object> map = new HashMap<>();
        map.putAll(getDefaultUriVariables());
        map.putAll(uriVariables);
        uriVariables = map;
    } 
    URI url = expandInternal(uriTemplate, uriVariables);
    return insertBaseUrl(url);
}
org.springframework.web.util.AbstractUriTemplateHandler

@Override public URI expand(String uriTemplate, Object... uriVariables)

{
    URI url = expandInternal(uriTemplate, uriVariables);
    return insertBaseUrl(url);
}
org.springframework.web.util.AbstractUriTemplateHandler

protected abstract URI expandInternal(String uriTemplate, Map<String, ?> uriVariables)

org.springframework.web.util.AbstractUriTemplateHandler

protected abstract URI expandInternal(String uriTemplate, Object... uriVariables)

org.springframework.web.util.AbstractUriTemplateHandler

@Nullable public String getBaseUrl()

{
    return this.baseUrl;
}
org.springframework.web.util.AbstractUriTemplateHandler

public Map<String, ?> getDefaultUriVariables()

{
    return Collections.unmodifiableMap(this.defaultUriVariables);
}
org.springframework.web.util.AbstractUriTemplateHandler

public void setDefaultUriVariables(@Nullable Map<String, ?> defaultUriVariables)

{
    this.defaultUriVariables.clear();
    if (defaultUriVariables != null) {
        this.defaultUriVariables.putAll(defaultUriVariables);
    } 
}

ContentCachingRequestWrapper
extends HttpServletRequestWrapper

org.springframework.web.util.ContentCachingRequestWrapper

public ContentCachingRequestWrapper ContentCachingRequestWrapper(HttpServletRequest request)

{
    super(request);
    int contentLength = request.getContentLength();
    this.cachedContent = new ByteArrayOutputStream(contentLength >= 0 ? contentLength : 1024);
    this.contentCacheLimit = null;
}
org.springframework.web.util.ContentCachingRequestWrapper

public ContentCachingRequestWrapper ContentCachingRequestWrapper(HttpServletRequest request, int contentCacheLimit)

{
    super(request);
    this.cachedContent = new ByteArrayOutputStream(contentCacheLimit);
    this.contentCacheLimit = contentCacheLimit;
}
org.springframework.web.util.ContentCachingRequestWrapper

@Override public String getCharacterEncoding()

{
    String enc = super.getCharacterEncoding();
    return (enc != null ? enc : WebUtils.DEFAULT_CHARACTER_ENCODING);
}
org.springframework.web.util.ContentCachingRequestWrapper

public byte[] getContentAsByteArray()

{
    return this.cachedContent.toByteArray();
}
org.springframework.web.util.ContentCachingRequestWrapper

@Override public ServletInputStream getInputStream()

{
    if (this.inputStream == null) {
        this.inputStream = new ContentCachingInputStream(getRequest().getInputStream());
    } 
    return this.inputStream;
}
org.springframework.web.util.ContentCachingRequestWrapper

@Override public String getParameter(String name)

{
    if (this.cachedContent.size() == 0 && isFormPost()) {
        writeRequestParametersToCachedContent();
    } 
    return super.getParameter(name);
}
org.springframework.web.util.ContentCachingRequestWrapper

@Override public Map<String, String[]> getParameterMap()

{
    if (this.cachedContent.size() == 0 && isFormPost()) {
        writeRequestParametersToCachedContent();
    } 
    return super.getParameterMap();
}
org.springframework.web.util.ContentCachingRequestWrapper

@Override public Enumeration<String> getParameterNames()

{
    if (this.cachedContent.size() == 0 && isFormPost()) {
        writeRequestParametersToCachedContent();
    } 
    return super.getParameterNames();
}
org.springframework.web.util.ContentCachingRequestWrapper

@Override public String[] getParameterValues(String name)

{
    if (this.cachedContent.size() == 0 && isFormPost()) {
        writeRequestParametersToCachedContent();
    } 
    return super.getParameterValues(name);
}
org.springframework.web.util.ContentCachingRequestWrapper

@Override public BufferedReader getReader()

{
    if (this.reader == null) {
        this.reader = new BufferedReader(new InputStreamReader(getInputStream(), getCharacterEncoding()));
    } 
    return this.reader;
}
org.springframework.web.util.ContentCachingRequestWrapper

protected void handleContentOverflow(int contentCacheLimit)

{
}

ContentCachingResponseWrapper
extends HttpServletResponseWrapper

org.springframework.web.util.ContentCachingResponseWrapper

public ContentCachingResponseWrapper ContentCachingResponseWrapper(HttpServletResponse response)

{
    super(response);
}
org.springframework.web.util.ContentCachingResponseWrapper

public void copyBodyToResponse()

{
    copyBodyToResponse(true);
}
org.springframework.web.util.ContentCachingResponseWrapper

@Override public void flushBuffer()

{
}
org.springframework.web.util.ContentCachingResponseWrapper

public byte[] getContentAsByteArray()

{
    return this.content.toByteArray();
}
org.springframework.web.util.ContentCachingResponseWrapper

public InputStream getContentInputStream()

{
    return this.content.getInputStream();
}
org.springframework.web.util.ContentCachingResponseWrapper

public int getContentSize()

{
    return this.content.size();
}
org.springframework.web.util.ContentCachingResponseWrapper

@Override public ServletOutputStream getOutputStream()

{
    if (this.outputStream == null) {
        this.outputStream = new ResponseServletOutputStream(getResponse().getOutputStream());
    } 
    return this.outputStream;
}
org.springframework.web.util.ContentCachingResponseWrapper

@Deprecated public int getStatusCode()

{
    return getStatus();
}
org.springframework.web.util.ContentCachingResponseWrapper

@Override public void reset()

{
    super.reset();
    this.content.reset();
}
org.springframework.web.util.ContentCachingResponseWrapper

@Override public void resetBuffer()

{
    this.content.reset();
}
org.springframework.web.util.ContentCachingResponseWrapper

@Override public void sendError(int sc)

{
    copyBodyToResponse(false);
    try {
        super.sendError(sc);
    } catch (IllegalStateException ex) {
        super.setStatus(sc);
    }
}
org.springframework.web.util.ContentCachingResponseWrapper

@Override @SuppressWarnings("deprecation") public void sendError(int sc, String msg)

{
    copyBodyToResponse(false);
    try {
        super.sendError(sc, msg);
    } catch (IllegalStateException ex) {
        super.setStatus(sc, msg);
    }
}
org.springframework.web.util.ContentCachingResponseWrapper

@Override public void sendRedirect(String location)

{
    copyBodyToResponse(false);
    super.sendRedirect(location);
}
org.springframework.web.util.ContentCachingResponseWrapper

@Override public void setBufferSize(int size)

{
    if (size > this.content.size()) {
        this.content.resize(size);
    } 
}
org.springframework.web.util.ContentCachingResponseWrapper

@Override public void setContentLength(int len)

{
    if (len > this.content.size()) {
        this.content.resize(len);
    } 
    this.contentLength = len;
}
org.springframework.web.util.ContentCachingResponseWrapper

@Override public void setContentLengthLong(long len)

{
    if (len > Integer.MAX_VALUE) {
        throw new IllegalArgumentException("Content-Length exceeds ContentCachingResponseWrapper's maximum (" + Integer.MAX_VALUE + "): " + len);
    } 
    int lenInt = (int)len;
    if (lenInt > this.content.size()) {
        this.content.resize(lenInt);
    } 
    this.contentLength = lenInt;
}

CookieGenerator

org.springframework.web.util.CookieGenerator

public void addCookie(HttpServletResponse response, String cookieValue)

{
    Assert.notNull(response, "HttpServletResponse must not be null");
    Cookie cookie = createCookie(cookieValue);
    Integer maxAge = getCookieMaxAge();
    if (maxAge != null) {
        cookie.setMaxAge(maxAge);
    } 
    if (isCookieSecure()) {
        cookie.setSecure(true);
    } 
    if (isCookieHttpOnly()) {
        cookie.setHttpOnly(true);
    } 
    response.addCookie(cookie);
    if (logger.isTraceEnabled()) {
        logger.trace("Added cookie [" + getCookieName() + "=" + cookieValue + "]");
    } 
}
org.springframework.web.util.CookieGenerator

protected Cookie createCookie(String cookieValue)

{
    Cookie cookie = new Cookie(getCookieName(), cookieValue);
    if (getCookieDomain() != null) {
        cookie.setDomain(getCookieDomain());
    } 
    cookie.setPath(getCookiePath());
    return cookie;
}
org.springframework.web.util.CookieGenerator

@Nullable public String getCookieDomain()

{
    return this.cookieDomain;
}
org.springframework.web.util.CookieGenerator

@Nullable public Integer getCookieMaxAge()

{
    return this.cookieMaxAge;
}
org.springframework.web.util.CookieGenerator

@Nullable public String getCookieName()

{
    return this.cookieName;
}
org.springframework.web.util.CookieGenerator

public String getCookiePath()

{
    return this.cookiePath;
}
org.springframework.web.util.CookieGenerator

public boolean isCookieHttpOnly()

{
    return this.cookieHttpOnly;
}
org.springframework.web.util.CookieGenerator

public boolean isCookieSecure()

{
    return this.cookieSecure;
}
org.springframework.web.util.CookieGenerator

protected final Log logger

org.springframework.web.util.CookieGenerator

public void removeCookie(HttpServletResponse response)

{
    Assert.notNull(response, "HttpServletResponse must not be null");
    Cookie cookie = createCookie("");
    cookie.setMaxAge(0);
    if (isCookieSecure()) {
        cookie.setSecure(true);
    } 
    if (isCookieHttpOnly()) {
        cookie.setHttpOnly(true);
    } 
    response.addCookie(cookie);
    if (logger.isTraceEnabled()) {
        logger.trace("Removed cookie '" + getCookieName() + "'");
    } 
}
org.springframework.web.util.CookieGenerator

public void setCookieDomain(@Nullable String cookieDomain)

{
    this.cookieDomain = cookieDomain;
}
org.springframework.web.util.CookieGenerator

public void setCookieHttpOnly(boolean cookieHttpOnly)

{
    this.cookieHttpOnly = cookieHttpOnly;
}
org.springframework.web.util.CookieGenerator

public void setCookieMaxAge(@Nullable Integer cookieMaxAge)

{
    this.cookieMaxAge = cookieMaxAge;
}
org.springframework.web.util.CookieGenerator

public void setCookieName(@Nullable String cookieName)

{
    this.cookieName = cookieName;
}
org.springframework.web.util.CookieGenerator

public void setCookiePath(String cookiePath)

{
    this.cookiePath = cookiePath;
}
org.springframework.web.util.CookieGenerator

public void setCookieSecure(boolean cookieSecure)

{
    this.cookieSecure = cookieSecure;
}

DefaultUriBuilderFactory
implements UriBuilderFactory

org.springframework.web.util.DefaultUriBuilderFactory

public DefaultUriBuilderFactory DefaultUriBuilderFactory()

{
    this.baseUri = null;
}
org.springframework.web.util.DefaultUriBuilderFactory

public DefaultUriBuilderFactory DefaultUriBuilderFactory(String baseUriTemplate)

{
    this.baseUri = UriComponentsBuilder.fromUriString(baseUriTemplate);
}
org.springframework.web.util.DefaultUriBuilderFactory

public DefaultUriBuilderFactory DefaultUriBuilderFactory(UriComponentsBuilder baseUri)

{
    this.baseUri = baseUri;
}

EncodingMode

enum values
  • TEMPLATE_AND_VALUES
  • VALUES_ONLY
  • URI_COMPONENT
  • NONE
org.springframework.web.util.DefaultUriBuilderFactory

@Override public UriBuilder builder()

{
    return new DefaultUriBuilder("");
}
org.springframework.web.util.DefaultUriBuilderFactory

@Override public URI expand(String uriTemplate, Map<String, ?> uriVars)

{
    return uriString(uriTemplate).build(uriVars);
}
org.springframework.web.util.DefaultUriBuilderFactory

@Override public URI expand(String uriTemplate, Object... uriVars)

{
    return uriString(uriTemplate).build(uriVars);
}
org.springframework.web.util.DefaultUriBuilderFactory

public Map<String, ?> getDefaultUriVariables()

{
    return Collections.unmodifiableMap(this.defaultUriVariables);
}
org.springframework.web.util.DefaultUriBuilderFactory

public EncodingMode getEncodingMode()

{
    return this.encodingMode;
}
org.springframework.web.util.DefaultUriBuilderFactory

public void setDefaultUriVariables(@Nullable Map<String, ?> defaultUriVariables)

{
    this.defaultUriVariables.clear();
    if (defaultUriVariables != null) {
        this.defaultUriVariables.putAll(defaultUriVariables);
    } 
}
org.springframework.web.util.DefaultUriBuilderFactory

public void setEncodingMode(EncodingMode encodingMode)

{
    this.encodingMode = encodingMode;
}
org.springframework.web.util.DefaultUriBuilderFactory

public void setParsePath(boolean parsePath)

{
    this.parsePath = parsePath;
}
org.springframework.web.util.DefaultUriBuilderFactory

public boolean shouldParsePath()

{
    return this.parsePath;
}
org.springframework.web.util.DefaultUriBuilderFactory

@Override public UriBuilder uriString(String uriTemplate)

{
    return new DefaultUriBuilder(uriTemplate);
}

DefaultUriTemplateHandler
extends AbstractUriTemplateHandler

org.springframework.web.util.DefaultUriTemplateHandler

protected UriComponents expandAndEncode(UriComponentsBuilder builder, Map<String, ?> uriVariables)

{
    if (!isStrictEncoding()) {
        return builder.buildAndExpand(uriVariables).encode();
    } else {
        Map<String, ?> encodedUriVars = UriUtils.encodeUriVariables(uriVariables);
        return builder.buildAndExpand(encodedUriVars);
    }
}
org.springframework.web.util.DefaultUriTemplateHandler

protected UriComponents expandAndEncode(UriComponentsBuilder builder, Object[] uriVariables)

{
    if (!isStrictEncoding()) {
        return builder.buildAndExpand(uriVariables).encode();
    } else {
        Object[] encodedUriVars = UriUtils.encodeUriVariables(uriVariables);
        return builder.buildAndExpand(encodedUriVars);
    }
}
org.springframework.web.util.DefaultUriTemplateHandler

@Override protected URI expandInternal(String uriTemplate, Map<String, ?> uriVariables)

{
    UriComponentsBuilder uriComponentsBuilder = initUriComponentsBuilder(uriTemplate);
    UriComponents uriComponents = expandAndEncode(uriComponentsBuilder, uriVariables);
    return createUri(uriComponents);
}
org.springframework.web.util.DefaultUriTemplateHandler

@Override protected URI expandInternal(String uriTemplate, Object... uriVariables)

{
    UriComponentsBuilder uriComponentsBuilder = initUriComponentsBuilder(uriTemplate);
    UriComponents uriComponents = expandAndEncode(uriComponentsBuilder, uriVariables);
    return createUri(uriComponents);
}
org.springframework.web.util.DefaultUriTemplateHandler

public boolean isStrictEncoding()

{
    return this.strictEncoding;
}
org.springframework.web.util.DefaultUriTemplateHandler

public void setParsePath(boolean parsePath)

{
    this.parsePath = parsePath;
}
org.springframework.web.util.DefaultUriTemplateHandler

public void setStrictEncoding(boolean strictEncoding)

{
    this.strictEncoding = strictEncoding;
}
org.springframework.web.util.DefaultUriTemplateHandler

public boolean shouldParsePath()

{
    return this.parsePath;
}

HierarchicalUriComponents
extends UriComponents

org.springframework.web.util.HierarchicalUriComponents

@Override protected void copyToUriComponentsBuilder(UriComponentsBuilder builder)

{
    if (getScheme() != null) {
        builder.scheme(getScheme());
    } 
    if (getUserInfo() != null) {
        builder.userInfo(getUserInfo());
    } 
    if (getHost() != null) {
        builder.host(getHost());
    } 
    if (this.port != null) {
        builder.port(this.port);
    } 
    this.path.copyToUriComponentsBuilder(builder);
    if (!getQueryParams().isEmpty()) {
        builder.queryParams(getQueryParams());
    } 
    if (getFragment() != null) {
        builder.fragment(getFragment());
    } 
}
org.springframework.web.util.HierarchicalUriComponents

@Override public HierarchicalUriComponents encode(Charset charset)

{
    if (this.encodeState.isEncoded()) {
        return this;
    } 
    String scheme = getScheme();
    String fragment = getFragment();
    String schemeTo = (scheme != null ? encodeUriComponent(scheme, charset, Type.SCHEME) : null);
    String fragmentTo = (fragment != null ? encodeUriComponent(fragment, charset, Type.FRAGMENT) : null);
    String userInfoTo = (this.userInfo != null ? encodeUriComponent(this.userInfo, charset, Type.USER_INFO) : null);
    String hostTo = (this.host != null ? encodeUriComponent(this.host, charset, getHostType()) : null);
    BiFunction<String, Type, String> encoder = (s, type) -> encodeUriComponent(s, charset, type);
    PathComponent pathTo = this.path.encode(encoder);
    MultiValueMap<String, String> queryParamsTo = encodeQueryParams(encoder);
    return new HierarchicalUriComponents(schemeTo, fragmentTo, userInfoTo, hostTo, this.port, pathTo, queryParamsTo, EncodeState.FULLY_ENCODED, null);
}
org.springframework.web.util.HierarchicalUriComponents

@Override public boolean equals(@Nullable Object other)

{
    if (this == other) {
        return true;
    } 
    if (!(other instanceof HierarchicalUriComponents)) {
        return false;
    } 
    HierarchicalUriComponents otherComp = (HierarchicalUriComponents)other;
    return (ObjectUtils.nullSafeEquals(getScheme(), otherComp.getScheme()) && ObjectUtils.nullSafeEquals(getUserInfo(), otherComp.getUserInfo()) && ObjectUtils.nullSafeEquals(getHost(), otherComp.getHost()) && getPort() == otherComp.getPort() && this.path.equals(otherComp.path) && this.queryParams.equals(otherComp.queryParams) && ObjectUtils.nullSafeEquals(getFragment(), otherComp.getFragment()));
}
org.springframework.web.util.HierarchicalUriComponents

@Override @Nullable public String getHost()

{
    return this.host;
}
org.springframework.web.util.HierarchicalUriComponents

@Override @NonNull public String getPath()

{
    return this.path.getPath();
}
org.springframework.web.util.HierarchicalUriComponents

@Override public List<String> getPathSegments()

{
    return this.path.getPathSegments();
}
org.springframework.web.util.HierarchicalUriComponents

@Override public int getPort()

{
    if (this.port == null) {
        return -1;
    } else if (this.port.contains("{")) {
        throw new IllegalStateException("The port contains a URI variable but has not been expanded yet: " + this.port);
    } 
    return Integer.parseInt(this.port);
}
org.springframework.web.util.HierarchicalUriComponents

@Override public MultiValueMap<String, String> getQueryParams()

{
    return this.queryParams;
}
org.springframework.web.util.HierarchicalUriComponents

@Override @Nullable public String getSchemeSpecificPart()

{
    return null;
}
org.springframework.web.util.HierarchicalUriComponents

@Override @Nullable public String getUserInfo()

{
    return this.userInfo;
}
org.springframework.web.util.HierarchicalUriComponents

@Override public String toUriString()

{
    StringBuilder uriBuilder = new StringBuilder();
    if (getScheme() != null) {
        uriBuilder.append(getScheme()).append(':');
    } 
    if (this.userInfo != null || this.host != null) {
        uriBuilder.append("//");
        if (this.userInfo != null) {
            uriBuilder.append(this.userInfo).append('@');
        } 
        if (this.host != null) {
            uriBuilder.append(this.host);
        } 
        if (getPort() != -1) {
            uriBuilder.append(':').append(this.port);
        } 
    } 
    String path = getPath();
    if (StringUtils.hasLength(path)) {
        if (uriBuilder.length() != 0 && path.charAt(0) != PATH_DELIMITER) {
            uriBuilder.append(PATH_DELIMITER);
        } 
        uriBuilder.append(path);
    } 
    String query = getQuery();
    if (query != null) {
        uriBuilder.append('?').append(query);
    } 
    if (getFragment() != null) {
        uriBuilder.append('#').append(getFragment());
    } 
    return uriBuilder.toString();
}

HtmlCharacterEntityDecoder

org.springframework.web.util.HtmlCharacterEntityDecoder

public HtmlCharacterEntityDecoder HtmlCharacterEntityDecoder(HtmlCharacterEntityReferences characterEntityReferences, String original)

{
    this.characterEntityReferences = characterEntityReferences;
    this.originalMessage = original;
    this.decodedMessage = new StringBuilder(original.length());
}

HtmlCharacterEntityReferences

org.springframework.web.util.HtmlCharacterEntityReferences

public char convertToCharacter(String entityReference)

{
    Character referredCharacter = this.entityReferenceToCharacterMap.get(entityReference);
    if (referredCharacter != null) {
        return referredCharacter;
    } 
    return CHAR_NULL;
}
org.springframework.web.util.HtmlCharacterEntityReferences

@Nullable public String convertToReference(char character)

{
    return convertToReference(character, WebUtils.DEFAULT_CHARACTER_ENCODING);
}
org.springframework.web.util.HtmlCharacterEntityReferences

public int getSupportedReferenceCount()

{
    return this.entityReferenceToCharacterMap.size();
}
org.springframework.web.util.HtmlCharacterEntityReferences

public boolean isMappedToReference(char character)

{
    return isMappedToReference(character, WebUtils.DEFAULT_CHARACTER_ENCODING);
}
org.springframework.web.util.HtmlCharacterEntityReferences

public boolean isMappedToReference(char character, String encoding)

{
    return (convertToReference(character, encoding) != null);
}

HtmlUtils

org.springframework.web.util.HtmlUtils

public static String htmlEscape(String input)

{
    return htmlEscape(input, WebUtils.DEFAULT_CHARACTER_ENCODING);
}
org.springframework.web.util.HtmlUtils

public static String htmlEscapeDecimal(String input)

{
    return htmlEscapeDecimal(input, WebUtils.DEFAULT_CHARACTER_ENCODING);
}
org.springframework.web.util.HtmlUtils

public static String htmlEscapeHex(String input)

{
    return htmlEscapeHex(input, WebUtils.DEFAULT_CHARACTER_ENCODING);
}
org.springframework.web.util.HtmlUtils

public static String htmlUnescape(String input)

{
    return new HtmlCharacterEntityDecoder(characterEntityReferences, input).decode();
}

HttpSessionMutexListener
implements HttpSessionListener

org.springframework.web.util.HttpSessionMutexListener

@Override public void sessionCreated(HttpSessionEvent event)

{
    event.getSession().setAttribute(WebUtils.SESSION_MUTEX_ATTRIBUTE, new Mutex());
}
org.springframework.web.util.HttpSessionMutexListener

@Override public void sessionDestroyed(HttpSessionEvent event)

{
    event.getSession().removeAttribute(WebUtils.SESSION_MUTEX_ATTRIBUTE);
}

IntrospectorCleanupListener
implements ServletContextListener

org.springframework.web.util.IntrospectorCleanupListener

@Override public void contextDestroyed(ServletContextEvent event)

{
    CachedIntrospectionResults.clearClassLoader(Thread.currentThread().getContextClassLoader());
    Introspector.flushCaches();
}
org.springframework.web.util.IntrospectorCleanupListener

@Override public void contextInitialized(ServletContextEvent event)

{
    CachedIntrospectionResults.acceptClassLoader(Thread.currentThread().getContextClassLoader());
}

JavaScriptUtils

org.springframework.web.util.JavaScriptUtils

public static String javaScriptEscape(String input)

{
    StringBuilder filtered = new StringBuilder(input.length());
    char prevChar = '\u0000';
    char c;
    for (int i = 0; i < input.length(); i++) {
        c = input.charAt(i);
        if (c == '"') {
            filtered.append("\\\"");
        } else if (c == '\'') {
            filtered.append("\\'");
        } else if (c == '\\') {
            filtered.append("\\\\");
        } else if (c == '/') {
            filtered.append("\\/");
        } else if (c == '\t') {
            filtered.append("\\t");
        } else if (c == '\n') {
            if (prevChar != '\r') {
                filtered.append("\\n");
            } 
        } else if (c == '\r') {
            filtered.append("\\n");
        } else if (c == '\f') {
            filtered.append("\\f");
        } else if (c == '\b') {
            filtered.append("\\b");
        } else if (c == '\013') {
            filtered.append("\\v");
        } else if (c == '<') {
            filtered.append("\\u003C");
        } else if (c == '>') {
            filtered.append("\\u003E");
        } else if (c == '\u2028') {
            filtered.append("\\u2028");
        } else if (c == '\u2029') {
            filtered.append("\\u2029");
        } else {
            filtered.append(c);
        }
        prevChar = c;
    }
    return filtered.toString();
}

NestedServletException
extends ServletException

org.springframework.web.util.NestedServletException

public NestedServletException NestedServletException(String msg)

{
    super(msg);
}
org.springframework.web.util.NestedServletException

public NestedServletException NestedServletException(@Nullable String msg, @Nullable Throwable cause)

{
    super(msg, cause);
}
org.springframework.web.util.NestedServletException

@Override @Nullable public String getMessage()

{
    return NestedExceptionUtils.buildMessage(super.getMessage(), getCause());
}

OpaqueUriComponents
extends UriComponents

org.springframework.web.util.OpaqueUriComponents

@Override protected void copyToUriComponentsBuilder(UriComponentsBuilder builder)

{
    if (getScheme() != null) {
        builder.scheme(getScheme());
    } 
    if (getSchemeSpecificPart() != null) {
        builder.schemeSpecificPart(getSchemeSpecificPart());
    } 
    if (getFragment() != null) {
        builder.fragment(getFragment());
    } 
}
org.springframework.web.util.OpaqueUriComponents

@Override public UriComponents encode(Charset charset)

{
    return this;
}
org.springframework.web.util.OpaqueUriComponents

@Override public boolean equals(@Nullable Object other)

{
    if (this == other) {
        return true;
    } 
    if (!(other instanceof OpaqueUriComponents)) {
        return false;
    } 
    OpaqueUriComponents otherComp = (OpaqueUriComponents)other;
    return (ObjectUtils.nullSafeEquals(getScheme(), otherComp.getScheme()) && ObjectUtils.nullSafeEquals(this.ssp, otherComp.ssp) && ObjectUtils.nullSafeEquals(getFragment(), otherComp.getFragment()));
}
org.springframework.web.util.OpaqueUriComponents

@Override @Nullable public String getHost()

{
    return null;
}
org.springframework.web.util.OpaqueUriComponents

@Override @Nullable public String getPath()

{
    return null;
}
org.springframework.web.util.OpaqueUriComponents

@Override public List<String> getPathSegments()

{
    return Collections.emptyList();
}
org.springframework.web.util.OpaqueUriComponents

@Override public int getPort()

{
    return -1;
}
org.springframework.web.util.OpaqueUriComponents

@Override @Nullable public String getQuery()

{
    return null;
}
org.springframework.web.util.OpaqueUriComponents

@Override public MultiValueMap<String, String> getQueryParams()

{
    return QUERY_PARAMS_NONE;
}
org.springframework.web.util.OpaqueUriComponents

@Override @Nullable public String getSchemeSpecificPart()

{
    return this.ssp;
}
org.springframework.web.util.OpaqueUriComponents

@Override @Nullable public String getUserInfo()

{
    return null;
}
org.springframework.web.util.OpaqueUriComponents

@Override public UriComponents normalize()

{
    return this;
}
org.springframework.web.util.OpaqueUriComponents

@Override public URI toUri()

{
    try {
        return new URI(getScheme(), this.ssp, getFragment());
    } catch (URISyntaxException ex) {
        throw new IllegalStateException("Could not create URI object: " + ex.getMessage(), ex);
    }
}
org.springframework.web.util.OpaqueUriComponents

@Override public String toUriString()

{
    StringBuilder uriBuilder = new StringBuilder();
    if (getScheme() != null) {
        uriBuilder.append(getScheme());
        uriBuilder.append(':');
    } 
    if (this.ssp != null) {
        uriBuilder.append(this.ssp);
    } 
    if (getFragment() != null) {
        uriBuilder.append('#');
        uriBuilder.append(getFragment());
    } 
    return uriBuilder.toString();
}

ServletContextPropertyUtils

org.springframework.web.util.ServletContextPropertyUtils

public static String resolvePlaceholders(String text, ServletContext servletContext)

{
    return resolvePlaceholders(text, servletContext, false);
}
org.springframework.web.util.ServletContextPropertyUtils

public static String resolvePlaceholders(String text, ServletContext servletContext, boolean ignoreUnresolvablePlaceholders)

{
    PropertyPlaceholderHelper helper = (ignoreUnresolvablePlaceholders ? nonStrictHelper : strictHelper);
    return helper.replacePlaceholders(text, new ServletContextPlaceholderResolver(text, servletContext));
}

TagUtils

org.springframework.web.util.TagUtils

public static final String SCOPE_APPLICATION

org.springframework.web.util.TagUtils

public static final String SCOPE_PAGE

org.springframework.web.util.TagUtils

public static final String SCOPE_REQUEST

org.springframework.web.util.TagUtils

public static final String SCOPE_SESSION

org.springframework.web.util.TagUtils

public static int getScope(String scope)

{
    Assert.notNull(scope, "Scope to search for cannot be null");
    if (scope.equals(SCOPE_REQUEST)) {
        return PageContext.REQUEST_SCOPE;
    } else if (scope.equals(SCOPE_SESSION)) {
        return PageContext.SESSION_SCOPE;
    } else if (scope.equals(SCOPE_APPLICATION)) {
        return PageContext.APPLICATION_SCOPE;
    } else {
        return PageContext.PAGE_SCOPE;
    }
}

UriBuilder

UriBuilderFactory
inherit classes
  • UriTemplateHandler

UriComponents
implements Serializable

org.springframework.web.util.UriComponents

protected UriComponents UriComponents(@Nullable String scheme, @Nullable String fragment)

{
    this.scheme = scheme;
    this.fragment = fragment;
}
UriTemplateVariables
org.springframework.web.util.UriComponents

protected abstract void copyToUriComponentsBuilder(UriComponentsBuilder builder)

org.springframework.web.util.UriComponents

public final UriComponents encode()

{
    return encode(StandardCharsets.UTF_8);
}
org.springframework.web.util.UriComponents

public abstract UriComponents encode(Charset charset)

org.springframework.web.util.UriComponents

public final UriComponents expand(Map<String, ?> uriVariables)

{
    Assert.notNull(uriVariables, "'uriVariables' must not be null");
    return expandInternal(new MapTemplateVariables(uriVariables));
}
org.springframework.web.util.UriComponents

public final UriComponents expand(Object... uriVariableValues)

{
    Assert.notNull(uriVariableValues, "'uriVariableValues' must not be null");
    return expandInternal(new VarArgsTemplateVariables(uriVariableValues));
}
org.springframework.web.util.UriComponents

public final UriComponents expand(UriTemplateVariables uriVariables)

{
    Assert.notNull(uriVariables, "'uriVariables' must not be null");
    return expandInternal(uriVariables);
}
org.springframework.web.util.UriComponents

@Nullable public final String getFragment()

{
    return this.fragment;
}
org.springframework.web.util.UriComponents

@Nullable public abstract String getHost()

org.springframework.web.util.UriComponents

@Nullable public abstract String getPath()

org.springframework.web.util.UriComponents

public abstract List<String> getPathSegments()

org.springframework.web.util.UriComponents

public abstract int getPort()

org.springframework.web.util.UriComponents

@Nullable public abstract String getQuery()

org.springframework.web.util.UriComponents

public abstract MultiValueMap<String, String> getQueryParams()

org.springframework.web.util.UriComponents

@Nullable public final String getScheme()

{
    return this.scheme;
}
org.springframework.web.util.UriComponents

@Nullable public abstract String getSchemeSpecificPart()

org.springframework.web.util.UriComponents

@Nullable public abstract String getUserInfo()

org.springframework.web.util.UriComponents

public abstract UriComponents normalize()

org.springframework.web.util.UriComponents

@Override public final String toString()

{
    return toUriString();
}
org.springframework.web.util.UriComponents

public abstract URI toUri()

org.springframework.web.util.UriComponents

public abstract String toUriString()


UriComponentsBuilder
implements UriBuilder, Cloneable

org.springframework.web.util.UriComponentsBuilder

protected UriComponentsBuilder UriComponentsBuilder()

{
    this.pathBuilder = new CompositePathComponentBuilder();
}
org.springframework.web.util.UriComponentsBuilder

public UriComponents build()

{
    return build(false);
}
org.springframework.web.util.UriComponentsBuilder

public UriComponents build(boolean encoded)

{
    return buildInternal(encoded ? EncodingHint.FULLY_ENCODED : this.encodeTemplate ? EncodingHint.ENCODE_TEMPLATE : EncodingHint.NONE);
}
org.springframework.web.util.UriComponentsBuilder

@Override public URI build(Object... uriVariables)

{
    return buildInternal(EncodingHint.ENCODE_TEMPLATE).expand(uriVariables).toUri();
}
org.springframework.web.util.UriComponentsBuilder

@Override public URI build(Map<String, ?> uriVariables)

{
    return buildInternal(EncodingHint.ENCODE_TEMPLATE).expand(uriVariables).toUri();
}
org.springframework.web.util.UriComponentsBuilder

public UriComponents buildAndExpand(Map<String, ?> uriVariables)

{
    return build().expand(uriVariables);
}
org.springframework.web.util.UriComponentsBuilder

public UriComponents buildAndExpand(Object... uriVariableValues)

{
    return build().expand(uriVariableValues);
}
org.springframework.web.util.UriComponentsBuilder

@Override public Object clone()

{
    return cloneBuilder();
}
org.springframework.web.util.UriComponentsBuilder

public UriComponentsBuilder cloneBuilder()

{
    return new UriComponentsBuilder(this);
}
org.springframework.web.util.UriComponentsBuilder

public final UriComponentsBuilder encode()

{
    return encode(StandardCharsets.UTF_8);
}
org.springframework.web.util.UriComponentsBuilder

public UriComponentsBuilder encode(Charset charset)

{
    this.encodeTemplate = true;
    this.charset = charset;
    return this;
}
org.springframework.web.util.UriComponentsBuilder

@Override public UriComponentsBuilder fragment(@Nullable String fragment)

{
    if (fragment != null) {
        Assert.hasLength(fragment, "Fragment must not be empty");
        this.fragment = fragment;
    } else {
        this.fragment = null;
    }
    return this;
}
org.springframework.web.util.UriComponentsBuilder

public static UriComponentsBuilder fromHttpRequest(HttpRequest request)

{
    return fromUri(request.getURI()).adaptFromForwardedHeaders(request.getHeaders());
}
org.springframework.web.util.UriComponentsBuilder

public static UriComponentsBuilder fromPath(String path)

{
    UriComponentsBuilder builder = new UriComponentsBuilder();
    builder.path(path);
    return builder;
}
org.springframework.web.util.UriComponentsBuilder

public static UriComponentsBuilder fromUri(URI uri)

{
    UriComponentsBuilder builder = new UriComponentsBuilder();
    builder.uri(uri);
    return builder;
}
org.springframework.web.util.UriComponentsBuilder

@Override public UriComponentsBuilder host(@Nullable String host)

{
    this.host = host;
    resetSchemeSpecificPart();
    return this;
}
org.springframework.web.util.UriComponentsBuilder

public static UriComponentsBuilder newInstance()

{
    return new UriComponentsBuilder();
}
org.springframework.web.util.UriComponentsBuilder

@Override public UriComponentsBuilder path(String path)

{
    this.pathBuilder.addPath(path);
    resetSchemeSpecificPart();
    return this;
}
org.springframework.web.util.UriComponentsBuilder

@Override public UriComponentsBuilder pathSegment(String... pathSegments)

{
    this.pathBuilder.addPathSegments(pathSegments);
    resetSchemeSpecificPart();
    return this;
}
org.springframework.web.util.UriComponentsBuilder

@Override public UriComponentsBuilder port(int port)

{
    Assert.isTrue(port >= -1, "Port must be >= -1");
    this.port = String.valueOf(port);
    resetSchemeSpecificPart();
    return this;
}
org.springframework.web.util.UriComponentsBuilder

@Override public UriComponentsBuilder port(@Nullable String port)

{
    this.port = port;
    resetSchemeSpecificPart();
    return this;
}
org.springframework.web.util.UriComponentsBuilder

@Override public UriComponentsBuilder queryParam(String name, Object... values)

{
    Assert.notNull(name, "Name must not be null");
    if (!ObjectUtils.isEmpty(values)) {
        for (Object value: values) {
            String valueAsString = (value != null ? value.toString() : null);
            this.queryParams.add(name, valueAsString);
        }
    } else {
        this.queryParams.add(name, null);
    }
    resetSchemeSpecificPart();
    return this;
}
org.springframework.web.util.UriComponentsBuilder

@Override public UriComponentsBuilder queryParam(String name, @Nullable Collection<?> values)

{
    return queryParam(name, values != null ? values.toArray() : EMPTY_VALUES);
}
org.springframework.web.util.UriComponentsBuilder

@Override public UriComponentsBuilder queryParams(@Nullable MultiValueMap<String, String> params)

{
    if (params != null) {
        this.queryParams.addAll(params);
    } 
    return this;
}
org.springframework.web.util.UriComponentsBuilder

@Override public UriComponentsBuilder replacePath(@Nullable String path)

{
    this.pathBuilder = new CompositePathComponentBuilder();
    if (path != null) {
        this.pathBuilder.addPath(path);
    } 
    resetSchemeSpecificPart();
    return this;
}
org.springframework.web.util.UriComponentsBuilder

@Override public UriComponentsBuilder replaceQuery(@Nullable String query)

{
    this.queryParams.clear();
    if (query != null) {
        query(query);
    } 
    resetSchemeSpecificPart();
    return this;
}
org.springframework.web.util.UriComponentsBuilder

@Override public UriComponentsBuilder replaceQueryParam(String name, Object... values)

{
    Assert.notNull(name, "Name must not be null");
    this.queryParams.remove(name);
    if (!ObjectUtils.isEmpty(values)) {
        queryParam(name, values);
    } 
    resetSchemeSpecificPart();
    return this;
}
org.springframework.web.util.UriComponentsBuilder

@Override public UriComponentsBuilder replaceQueryParam(String name, @Nullable Collection<?> values)

{
    return replaceQueryParam(name, values != null ? values.toArray() : EMPTY_VALUES);
}
org.springframework.web.util.UriComponentsBuilder

@Override public UriComponentsBuilder replaceQueryParams(@Nullable MultiValueMap<String, String> params)

{
    this.queryParams.clear();
    if (params != null) {
        this.queryParams.putAll(params);
    } 
    return this;
}
org.springframework.web.util.UriComponentsBuilder

@Override public UriComponentsBuilder scheme(@Nullable String scheme)

{
    this.scheme = scheme;
    return this;
}
org.springframework.web.util.UriComponentsBuilder

public UriComponentsBuilder schemeSpecificPart(String ssp)

{
    this.ssp = ssp;
    resetHierarchicalComponents();
    return this;
}
org.springframework.web.util.UriComponentsBuilder

public UriComponentsBuilder uriComponents(UriComponents uriComponents)

{
    Assert.notNull(uriComponents, "UriComponents must not be null");
    uriComponents.copyToUriComponentsBuilder(this);
    return this;
}
org.springframework.web.util.UriComponentsBuilder

public UriComponentsBuilder uriVariables(Map<String, Object> uriVariables)

{
    this.uriVariables.putAll(uriVariables);
    return this;
}
org.springframework.web.util.UriComponentsBuilder

@Override public UriComponentsBuilder userInfo(@Nullable String userInfo)

{
    this.userInfo = userInfo;
    resetSchemeSpecificPart();
    return this;
}

UriTemplate
implements Serializable

org.springframework.web.util.UriTemplate

public List<String> getVariableNames()

{
    return this.variableNames;
}
org.springframework.web.util.UriTemplate

public boolean matches(@Nullable String uri)

{
    if (uri == null) {
        return false;
    } 
    Matcher matcher = this.matchPattern.matcher(uri);
    return matcher.matches();
}
org.springframework.web.util.UriTemplate

@Override public String toString()

{
    return this.uriTemplate;
}

UriTemplateHandler

UriUtils

org.springframework.web.util.UriUtils

public static String decode(String source, String encoding)

{
    return StringUtils.uriDecode(source, Charset.forName(encoding));
}
org.springframework.web.util.UriUtils

public static String decode(String source, Charset charset)

{
    return StringUtils.uriDecode(source, charset);
}
org.springframework.web.util.UriUtils

public static String encode(String source, String encoding)

{
    return encode(source, encoding, HierarchicalUriComponents.Type.URI);
}
org.springframework.web.util.UriUtils

public static String encode(String source, Charset charset)

{
    return encode(source, charset, HierarchicalUriComponents.Type.URI);
}
org.springframework.web.util.UriUtils

public static String encodeAuthority(String authority, String encoding)

{
    return encode(authority, encoding, HierarchicalUriComponents.Type.AUTHORITY);
}
org.springframework.web.util.UriUtils

public static String encodeAuthority(String authority, Charset charset)

{
    return encode(authority, charset, HierarchicalUriComponents.Type.AUTHORITY);
}
org.springframework.web.util.UriUtils

public static String encodeFragment(String fragment, String encoding)

{
    return encode(fragment, encoding, HierarchicalUriComponents.Type.FRAGMENT);
}
org.springframework.web.util.UriUtils

public static String encodeFragment(String fragment, Charset charset)

{
    return encode(fragment, charset, HierarchicalUriComponents.Type.FRAGMENT);
}
org.springframework.web.util.UriUtils

public static String encodeHost(String host, String encoding)

{
    return encode(host, encoding, HierarchicalUriComponents.Type.HOST_IPV4);
}
org.springframework.web.util.UriUtils

public static String encodeHost(String host, Charset charset)

{
    return encode(host, charset, HierarchicalUriComponents.Type.HOST_IPV4);
}
org.springframework.web.util.UriUtils

public static String encodePath(String path, String encoding)

{
    return encode(path, encoding, HierarchicalUriComponents.Type.PATH);
}
org.springframework.web.util.UriUtils

public static String encodePath(String path, Charset charset)

{
    return encode(path, charset, HierarchicalUriComponents.Type.PATH);
}
org.springframework.web.util.UriUtils

public static String encodePathSegment(String segment, String encoding)

{
    return encode(segment, encoding, HierarchicalUriComponents.Type.PATH_SEGMENT);
}
org.springframework.web.util.UriUtils

public static String encodePathSegment(String segment, Charset charset)

{
    return encode(segment, charset, HierarchicalUriComponents.Type.PATH_SEGMENT);
}
org.springframework.web.util.UriUtils

public static String encodePort(String port, String encoding)

{
    return encode(port, encoding, HierarchicalUriComponents.Type.PORT);
}
org.springframework.web.util.UriUtils

public static String encodePort(String port, Charset charset)

{
    return encode(port, charset, HierarchicalUriComponents.Type.PORT);
}
org.springframework.web.util.UriUtils

public static String encodeQuery(String query, String encoding)

{
    return encode(query, encoding, HierarchicalUriComponents.Type.QUERY);
}
org.springframework.web.util.UriUtils

public static String encodeQuery(String query, Charset charset)

{
    return encode(query, charset, HierarchicalUriComponents.Type.QUERY);
}
org.springframework.web.util.UriUtils

public static String encodeQueryParam(String queryParam, String encoding)

{
    return encode(queryParam, encoding, HierarchicalUriComponents.Type.QUERY_PARAM);
}
org.springframework.web.util.UriUtils

public static String encodeQueryParam(String queryParam, Charset charset)

{
    return encode(queryParam, charset, HierarchicalUriComponents.Type.QUERY_PARAM);
}
org.springframework.web.util.UriUtils

public static String encodeScheme(String scheme, String encoding)

{
    return encode(scheme, encoding, HierarchicalUriComponents.Type.SCHEME);
}
org.springframework.web.util.UriUtils

public static String encodeScheme(String scheme, Charset charset)

{
    return encode(scheme, charset, HierarchicalUriComponents.Type.SCHEME);
}
org.springframework.web.util.UriUtils

public static Object[] encodeUriVariables(Object... uriVariables)

{
    return Arrays.stream(uriVariables).map(value -> {
        String stringValue = (value != null ? value.toString() : "");
        return encode(stringValue, StandardCharsets.UTF_8);
    }).toArray();
}
org.springframework.web.util.UriUtils

public static String encodeUserInfo(String userInfo, String encoding)

{
    return encode(userInfo, encoding, HierarchicalUriComponents.Type.USER_INFO);
}
org.springframework.web.util.UriUtils

public static String encodeUserInfo(String userInfo, Charset charset)

{
    return encode(userInfo, charset, HierarchicalUriComponents.Type.USER_INFO);
}
org.springframework.web.util.UriUtils

@Nullable public static String extractFileExtension(String path)

{
    int end = path.indexOf('?');
    int fragmentIndex = path.indexOf('#');
    if (fragmentIndex != -1 && (end == -1 || fragmentIndex < end)) {
        end = fragmentIndex;
    } 
    if (end == -1) {
        end = path.length();
    } 
    int begin = path.lastIndexOf('/', end) + 1;
    int paramIndex = path.indexOf(';', begin);
    end = (paramIndex != -1 && paramIndex < end ? paramIndex : end);
    int extIndex = path.lastIndexOf('.', end);
    if (extIndex != -1 && extIndex > begin) {
        return path.substring(extIndex + 1, end);
    } 
    return null;
}

UrlPathHelper

org.springframework.web.util.UrlPathHelper

public MultiValueMap<String, String> decodeMatrixVariables(HttpServletRequest request, MultiValueMap<String, String> vars)

{
    if (this.urlDecode) {
        return vars;
    } else {
        MultiValueMap<String, String> decodedVars = new LinkedMultiValueMap<>(vars.size());
        vars.forEach((key, values) -> {
            for (String value: values) {
                decodedVars.add(key, decodeInternal(request, value));
            }
        });
        return decodedVars;
    }
}
org.springframework.web.util.UrlPathHelper

public Map<String, String> decodePathVariables(HttpServletRequest request, Map<String, String> vars)

{
    if (this.urlDecode) {
        return vars;
    } else {
        Map<String, String> decodedVars = new LinkedHashMap<>(vars.size());
        vars.forEach((key, value) -> decodedVars.put(key, decodeInternal(request, value)));
        return decodedVars;
    }
}
org.springframework.web.util.UrlPathHelper

public String decodeRequestString(HttpServletRequest request, String source)

{
    if (this.urlDecode) {
        return decodeInternal(request, source);
    } 
    return source;
}
org.springframework.web.util.UrlPathHelper

protected String determineEncoding(HttpServletRequest request)

{
    String enc = request.getCharacterEncoding();
    if (enc == null) {
        enc = getDefaultEncoding();
    } 
    return enc;
}
org.springframework.web.util.UrlPathHelper

public String getContextPath(HttpServletRequest request)

{
    String contextPath = (String)request.getAttribute(WebUtils.INCLUDE_CONTEXT_PATH_ATTRIBUTE);
    if (contextPath == null) {
        contextPath = request.getContextPath();
    } 
    if ("/".equals(contextPath)) {
        contextPath = "";
    } 
    return decodeRequestString(request, contextPath);
}
org.springframework.web.util.UrlPathHelper

protected String getDefaultEncoding()

{
    return this.defaultEncoding;
}
org.springframework.web.util.UrlPathHelper

public String getLookupPathForRequest(HttpServletRequest request)

{
    if (this.alwaysUseFullPath) {
        return getPathWithinApplication(request);
    } 
    String rest = getPathWithinServletMapping(request);
    if (!"".equals(rest)) {
        return rest;
    } else {
        return getPathWithinApplication(request);
    }
}
org.springframework.web.util.UrlPathHelper

public String getLookupPathForRequest(HttpServletRequest request, @Nullable String lookupPathAttributeName)

{
    if (lookupPathAttributeName != null) {
        String result = (String)request.getAttribute(lookupPathAttributeName);
        if (result != null) {
            return result;
        } 
    } 
    return getLookupPathForRequest(request);
}
org.springframework.web.util.UrlPathHelper

public String getOriginatingContextPath(HttpServletRequest request)

{
    String contextPath = (String)request.getAttribute(WebUtils.FORWARD_CONTEXT_PATH_ATTRIBUTE);
    if (contextPath == null) {
        contextPath = request.getContextPath();
    } 
    return decodeRequestString(request, contextPath);
}
org.springframework.web.util.UrlPathHelper

public String getOriginatingRequestUri(HttpServletRequest request)

{
    String uri = (String)request.getAttribute(WEBSPHERE_URI_ATTRIBUTE);
    if (uri == null) {
        uri = (String)request.getAttribute(WebUtils.FORWARD_REQUEST_URI_ATTRIBUTE);
        if (uri == null) {
            uri = request.getRequestURI();
        } 
    } 
    return decodeAndCleanUriString(request, uri);
}
org.springframework.web.util.UrlPathHelper

public String getOriginatingServletPath(HttpServletRequest request)

{
    String servletPath = (String)request.getAttribute(WebUtils.FORWARD_SERVLET_PATH_ATTRIBUTE);
    if (servletPath == null) {
        servletPath = request.getServletPath();
    } 
    return servletPath;
}
org.springframework.web.util.UrlPathHelper

public String getRequestUri(HttpServletRequest request)

{
    String uri = (String)request.getAttribute(WebUtils.INCLUDE_REQUEST_URI_ATTRIBUTE);
    if (uri == null) {
        uri = request.getRequestURI();
    } 
    return decodeAndCleanUriString(request, uri);
}
org.springframework.web.util.UrlPathHelper

public String getServletPath(HttpServletRequest request)

{
    String servletPath = (String)request.getAttribute(WebUtils.INCLUDE_SERVLET_PATH_ATTRIBUTE);
    if (servletPath == null) {
        servletPath = request.getServletPath();
    } 
    if (servletPath.length() > 1 && servletPath.endsWith("/") && shouldRemoveTrailingServletPathSlash(request)) {
        servletPath = servletPath.substring(0, servletPath.length() - 1);
    } 
    return servletPath;
}
org.springframework.web.util.UrlPathHelper

public boolean isUrlDecode()

{
    return this.urlDecode;
}
org.springframework.web.util.UrlPathHelper

public String removeSemicolonContent(String requestUri)

{
    return (this.removeSemicolonContent ? removeSemicolonContentInternal(requestUri) : removeJsessionid(requestUri));
}
org.springframework.web.util.UrlPathHelper

public void setAlwaysUseFullPath(boolean alwaysUseFullPath)

{
    this.alwaysUseFullPath = alwaysUseFullPath;
}
org.springframework.web.util.UrlPathHelper

public void setDefaultEncoding(String defaultEncoding)

{
    this.defaultEncoding = defaultEncoding;
}
org.springframework.web.util.UrlPathHelper

public void setRemoveSemicolonContent(boolean removeSemicolonContent)

{
    this.removeSemicolonContent = removeSemicolonContent;
}
org.springframework.web.util.UrlPathHelper

public void setUrlDecode(boolean urlDecode)

{
    this.urlDecode = urlDecode;
}
org.springframework.web.util.UrlPathHelper

public boolean shouldRemoveSemicolonContent()

{
    return this.removeSemicolonContent;
}
org.springframework.web.util.UrlPathHelper

@Nullable volatile static Boolean websphereComplianceFlag


WebAppRootListener
implements ServletContextListener

org.springframework.web.util.WebAppRootListener

@Override public void contextDestroyed(ServletContextEvent event)

{
    WebUtils.removeWebAppRootSystemProperty(event.getServletContext());
}
org.springframework.web.util.WebAppRootListener

@Override public void contextInitialized(ServletContextEvent event)

{
    WebUtils.setWebAppRootSystemProperty(event.getServletContext());
}

WebUtils

org.springframework.web.util.WebUtils

public static final String CONTENT_TYPE_CHARSET_PREFIX

org.springframework.web.util.WebUtils

public static final String DEFAULT_CHARACTER_ENCODING

org.springframework.web.util.WebUtils

public static final String DEFAULT_WEB_APP_ROOT_KEY

org.springframework.web.util.WebUtils

public static final String ERROR_EXCEPTION_ATTRIBUTE

org.springframework.web.util.WebUtils

public static final String ERROR_EXCEPTION_TYPE_ATTRIBUTE

org.springframework.web.util.WebUtils

public static final String ERROR_MESSAGE_ATTRIBUTE

org.springframework.web.util.WebUtils

public static final String ERROR_REQUEST_URI_ATTRIBUTE

org.springframework.web.util.WebUtils

public static final String ERROR_SERVLET_NAME_ATTRIBUTE

org.springframework.web.util.WebUtils

public static final String ERROR_STATUS_CODE_ATTRIBUTE

org.springframework.web.util.WebUtils

public static final String FORWARD_CONTEXT_PATH_ATTRIBUTE

org.springframework.web.util.WebUtils

public static final String FORWARD_PATH_INFO_ATTRIBUTE

org.springframework.web.util.WebUtils

public static final String FORWARD_QUERY_STRING_ATTRIBUTE

org.springframework.web.util.WebUtils

public static final String FORWARD_REQUEST_URI_ATTRIBUTE

org.springframework.web.util.WebUtils

public static final String FORWARD_SERVLET_PATH_ATTRIBUTE

org.springframework.web.util.WebUtils

public static final String HTML_ESCAPE_CONTEXT_PARAM

org.springframework.web.util.WebUtils

public static final String INCLUDE_CONTEXT_PATH_ATTRIBUTE

org.springframework.web.util.WebUtils

public static final String INCLUDE_PATH_INFO_ATTRIBUTE

org.springframework.web.util.WebUtils

public static final String INCLUDE_QUERY_STRING_ATTRIBUTE

org.springframework.web.util.WebUtils

public static final String INCLUDE_REQUEST_URI_ATTRIBUTE

org.springframework.web.util.WebUtils

public static final String INCLUDE_SERVLET_PATH_ATTRIBUTE

org.springframework.web.util.WebUtils

public static final String RESPONSE_ENCODED_HTML_ESCAPE_CONTEXT_PARAM

org.springframework.web.util.WebUtils

public static final String SESSION_MUTEX_ATTRIBUTE

org.springframework.web.util.WebUtils

public static final String[] SUBMIT_IMAGE_SUFFIXES

org.springframework.web.util.WebUtils

public static final String TEMP_DIR_CONTEXT_ATTRIBUTE

org.springframework.web.util.WebUtils

public static final String WEB_APP_ROOT_KEY_PARAM

org.springframework.web.util.WebUtils

@Nullable public static String findParameterValue(ServletRequest request, String name)

{
    return findParameterValue(request.getParameterMap(), name);
}
org.springframework.web.util.WebUtils

@Nullable public static String findParameterValue(Map<String, ?> parameters, String name)

{
    Object value = parameters.get(name);
    if (value instanceof String[]) {
        String[] values = (String[])value;
        return (values.length > 0 ? values[0] : null);
    } else if (value != null) {
        return value.toString();
    } 
    String prefix = name + "_";
    for (String paramName: parameters.keySet()) {
        if (paramName.startsWith(prefix)) {
            for (String suffix: SUBMIT_IMAGE_SUFFIXES) {
                if (paramName.endsWith(suffix)) {
                    return paramName.substring(prefix.length(), paramName.length() - suffix.length());
                } 
            }
            return paramName.substring(prefix.length());
        } 
    }
    return null;
}
org.springframework.web.util.WebUtils

@Nullable public static Cookie getCookie(HttpServletRequest request, String name)

{
    Assert.notNull(request, "Request must not be null");
    Cookie[] cookies = request.getCookies();
    if (cookies != null) {
        for (Cookie cookie: cookies) {
            if (name.equals(cookie.getName())) {
                return cookie;
            } 
        }
    } 
    return null;
}
org.springframework.web.util.WebUtils

@Nullable public static Boolean getDefaultHtmlEscape(@Nullable ServletContext servletContext)

{
    if (servletContext == null) {
        return null;
    } 
    String param = servletContext.getInitParameter(HTML_ESCAPE_CONTEXT_PARAM);
    return (StringUtils.hasText(param) ? Boolean.valueOf(param) : null);
}
org.springframework.web.util.WebUtils

<T>@SuppressWarnings("unchecked") @Nullable public static T getNativeRequest(ServletRequest request, @Nullable Class<T> requiredType)

{
    if (requiredType != null) {
        if (requiredType.isInstance(request)) {
            return (T)request;
        } else if (request instanceof ServletRequestWrapper) {
            return getNativeRequest(((ServletRequestWrapper)request).getRequest(), requiredType);
        } 
    } 
    return null;
}
org.springframework.web.util.WebUtils

<T>@SuppressWarnings("unchecked") @Nullable public static T getNativeResponse(ServletResponse response, @Nullable Class<T> requiredType)

{
    if (requiredType != null) {
        if (requiredType.isInstance(response)) {
            return (T)response;
        } else if (response instanceof ServletResponseWrapper) {
            return getNativeResponse(((ServletResponseWrapper)response).getResponse(), requiredType);
        } 
    } 
    return null;
}
org.springframework.web.util.WebUtils

public static String getRealPath(ServletContext servletContext, String path)

{
    Assert.notNull(servletContext, "ServletContext must not be null");
    if (!path.startsWith("/")) {
        path = "/" + path;
    } 
    String realPath = servletContext.getRealPath(path);
    if (realPath == null) {
        throw new FileNotFoundException("ServletContext resource [" + path + "] cannot be resolved to absolute file path - " + "web application archive not expanded?");
    } 
    return realPath;
}
org.springframework.web.util.WebUtils

public static Object getRequiredSessionAttribute(HttpServletRequest request, String name)

{
    Object attr = getSessionAttribute(request, name);
    if (attr == null) {
        throw new IllegalStateException("No session attribute '" + name + "' found");
    } 
    return attr;
}
org.springframework.web.util.WebUtils

@Nullable public static Boolean getResponseEncodedHtmlEscape(@Nullable ServletContext servletContext)

{
    if (servletContext == null) {
        return null;
    } 
    String param = servletContext.getInitParameter(RESPONSE_ENCODED_HTML_ESCAPE_CONTEXT_PARAM);
    return (StringUtils.hasText(param) ? Boolean.valueOf(param) : null);
}
org.springframework.web.util.WebUtils

@Nullable public static Object getSessionAttribute(HttpServletRequest request, String name)

{
    Assert.notNull(request, "Request must not be null");
    HttpSession session = request.getSession(false);
    return (session != null ? session.getAttribute(name) : null);
}
org.springframework.web.util.WebUtils

@Nullable public static String getSessionId(HttpServletRequest request)

{
    Assert.notNull(request, "Request must not be null");
    HttpSession session = request.getSession(false);
    return (session != null ? session.getId() : null);
}
org.springframework.web.util.WebUtils

public static Object getSessionMutex(HttpSession session)

{
    Assert.notNull(session, "Session must not be null");
    Object mutex = session.getAttribute(SESSION_MUTEX_ATTRIBUTE);
    if (mutex == null) {
        mutex = session;
    } 
    return mutex;
}
org.springframework.web.util.WebUtils

public static File getTempDir(ServletContext servletContext)

{
    Assert.notNull(servletContext, "ServletContext must not be null");
    return (File)servletContext.getAttribute(TEMP_DIR_CONTEXT_ATTRIBUTE);
}
org.springframework.web.util.WebUtils

public static boolean hasSubmitParameter(ServletRequest request, String name)

{
    Assert.notNull(request, "Request must not be null");
    if (request.getParameter(name) != null) {
        return true;
    } 
    for (String suffix: SUBMIT_IMAGE_SUFFIXES) {
        if (request.getParameter(name + suffix) != null) {
            return true;
        } 
    }
    return false;
}
org.springframework.web.util.WebUtils

public static boolean isIncludeRequest(ServletRequest request)

{
    return (request.getAttribute(INCLUDE_REQUEST_URI_ATTRIBUTE) != null);
}
org.springframework.web.util.WebUtils

public static boolean isSameOrigin(HttpRequest request)

{
    HttpHeaders headers = request.getHeaders();
    String origin = headers.getOrigin();
    if (origin == null) {
        return true;
    } 
    String scheme;
    String host;
    int port;
    if (request instanceof ServletServerHttpRequest) {
        HttpServletRequest servletRequest = ((ServletServerHttpRequest)request).getServletRequest();
        scheme = servletRequest.getScheme();
        host = servletRequest.getServerName();
        port = servletRequest.getServerPort();
    } else {
        URI uri = request.getURI();
        scheme = uri.getScheme();
        host = uri.getHost();
        port = uri.getPort();
    }
    UriComponents originUrl = UriComponentsBuilder.fromOriginHeader(origin).build();
    return (ObjectUtils.nullSafeEquals(scheme, originUrl.getScheme()) && ObjectUtils.nullSafeEquals(host, originUrl.getHost()) && getPort(scheme, port) == getPort(originUrl.getScheme(), originUrl.getPort()));
}
org.springframework.web.util.WebUtils

public static void setWebAppRootSystemProperty(ServletContext servletContext)

{
    Assert.notNull(servletContext, "ServletContext must not be null");
    String root = servletContext.getRealPath("/");
    if (root == null) {
        throw new IllegalStateException("Cannot set web app root system property when WAR file is not expanded");
    } 
    String param = servletContext.getInitParameter(WEB_APP_ROOT_KEY_PARAM);
    String key = (param != null ? param : DEFAULT_WEB_APP_ROOT_KEY);
    String oldValue = System.getProperty(key);
    if (oldValue != null && !StringUtils.pathEquals(oldValue, root)) {
        throw new IllegalStateException("Web app root system property already set to different value: '" + key + "' = [" + oldValue + "] instead of [" + root + "] - " + "Choose unique values for the 'webAppRootKey' context-param in your web.xml files!");
    } 
    System.setProperty(key, root);
    servletContext.log("Set web app root system property: '" + key + "' = [" + root + "]");
}


CaptureTheRestPathElement
extends PathElement

org.springframework.web.util.pattern.CaptureTheRestPathElement

@Override public int getCaptureCount()

{
    return 1;
}
org.springframework.web.util.pattern.CaptureTheRestPathElement

@Override public char[] getChars()

{
    return ("/{*" + this.variableName + "}").toCharArray();
}
org.springframework.web.util.pattern.CaptureTheRestPathElement

@Override public int getNormalizedLength()

{
    return 1;
}
org.springframework.web.util.pattern.CaptureTheRestPathElement

@Override public int getWildcardCount()

{
    return 0;
}
org.springframework.web.util.pattern.CaptureTheRestPathElement

@Override public boolean matches(int pathIndex, MatchingContext matchingContext)

{
    if (pathIndex < matchingContext.pathLength && !matchingContext.isSeparator(pathIndex)) {
        return false;
    } 
    if (matchingContext.determineRemainingPath) {
        matchingContext.remainingPathIndex = matchingContext.pathLength;
    } 
    if (matchingContext.extractingVariables) {
        MultiValueMap<String, String> parametersCollector = null;
        for (int i = pathIndex; i < matchingContext.pathLength; i++) {
            Element element = matchingContext.pathElements.get(i);
            if (element instanceof PathSegment) {
                MultiValueMap<String, String> parameters = ((PathSegment)element).parameters();
                if (!parameters.isEmpty()) {
                    if (parametersCollector == null) {
                        parametersCollector = new LinkedMultiValueMap<>();
                    } 
                    parametersCollector.addAll(parameters);
                } 
            } 
        }
        matchingContext.set(this.variableName, pathToString(pathIndex, matchingContext.pathElements), parametersCollector == null ? NO_PARAMETERS : parametersCollector);
    } 
    return true;
}
org.springframework.web.util.pattern.CaptureTheRestPathElement

@Override public String toString()

{
    return "CaptureTheRest(/{*" + this.variableName + "})";
}

CaptureVariablePathElement
extends PathElement

org.springframework.web.util.pattern.CaptureVariablePathElement

@Override public int getCaptureCount()

{
    return 1;
}
org.springframework.web.util.pattern.CaptureVariablePathElement

@Override public char[] getChars()

{
    StringBuilder b = new StringBuilder();
    b.append("{");
    b.append(this.variableName);
    if (this.constraintPattern != null) {
        b.append(":").append(this.constraintPattern.pattern());
    } 
    b.append("}");
    return b.toString().toCharArray();
}
org.springframework.web.util.pattern.CaptureVariablePathElement

@Override public int getNormalizedLength()

{
    return 1;
}
org.springframework.web.util.pattern.CaptureVariablePathElement

@Override public int getScore()

{
    return CAPTURE_VARIABLE_WEIGHT;
}
org.springframework.web.util.pattern.CaptureVariablePathElement

public String getVariableName()

{
    return this.variableName;
}
org.springframework.web.util.pattern.CaptureVariablePathElement

@Override public int getWildcardCount()

{
    return 0;
}
org.springframework.web.util.pattern.CaptureVariablePathElement

@Override public String toString()

{
    return "CaptureVariable({" + this.variableName + (this.constraintPattern != null ? ":" + this.constraintPattern.pattern() : "") + "})";
}

InternalPathPatternParser

org.springframework.web.util.pattern.InternalPathPatternParser

public PathPattern parse(String pathPattern)

{
    Assert.notNull(pathPattern, "Path pattern must not be null");
    this.pathPatternData = pathPattern.toCharArray();
    this.pathPatternLength = this.pathPatternData.length;
    this.headPE = null;
    this.currentPE = null;
    this.capturedVariableNames = null;
    this.pathElementStart = -1;
    this.pos = 0;
    resetPathElementState();
    while (this.pos < this.pathPatternLength) {
        char ch = this.pathPatternData[this.pos];
        char separator = this.parser.getPathOptions().separator();
        if (ch == separator) {
            if (this.pathElementStart != -1) {
                pushPathElement(createPathElement());
            } 
            if (peekDoubleWildcard()) {
                pushPathElement(new WildcardTheRestPathElement(this.pos, separator));
                this.pos += 2;
            } else {
                pushPathElement(new SeparatorPathElement(this.pos, separator));
            }
        } else {
            if (this.pathElementStart == -1) {
                this.pathElementStart = this.pos;
            } 
            if (ch == '?') {
                this.singleCharWildcardCount++;
            } else if (ch == '{') {
                if (this.insideVariableCapture) {
                    throw new PatternParseException(this.pos, this.pathPatternData, PatternMessage.ILLEGAL_NESTED_CAPTURE);
                } 
                this.insideVariableCapture = true;
                this.variableCaptureStart = this.pos;
            } else if (ch == '}') {
                if (!this.insideVariableCapture) {
                    throw new PatternParseException(this.pos, this.pathPatternData, PatternMessage.MISSING_OPEN_CAPTURE);
                } 
                this.insideVariableCapture = false;
                if (this.isCaptureTheRestVariable && (this.pos + 1) < this.pathPatternLength) {
                    throw new PatternParseException(this.pos + 1, this.pathPatternData, PatternMessage.NO_MORE_DATA_EXPECTED_AFTER_CAPTURE_THE_REST);
                } 
                this.variableCaptureCount++;
            } else if (ch == ':') {
                if (this.insideVariableCapture && !this.isCaptureTheRestVariable) {
                    skipCaptureRegex();
                    this.insideVariableCapture = false;
                    this.variableCaptureCount++;
                } 
            } else if (ch == '*') {
                if (this.insideVariableCapture && this.variableCaptureStart == this.pos - 1) {
                    this.isCaptureTheRestVariable = true;
                } 
                this.wildcard = true;
            } 
            if (this.insideVariableCapture) {
                if ((this.variableCaptureStart + 1 + (this.isCaptureTheRestVariable ? 1 : 0)) == this.pos && !Character.isJavaIdentifierStart(ch)) {
                    throw new PatternParseException(this.pos, this.pathPatternData, PatternMessage.ILLEGAL_CHARACTER_AT_START_OF_CAPTURE_DESCRIPTOR, Character.toString(ch));
                } else if ((this.pos > (this.variableCaptureStart + 1 + (this.isCaptureTheRestVariable ? 1 : 0)) && !Character.isJavaIdentifierPart(ch) && ch != '-')) {
                    throw new PatternParseException(this.pos, this.pathPatternData, PatternMessage.ILLEGAL_CHARACTER_IN_CAPTURE_DESCRIPTOR, Character.toString(ch));
                } 
            } 
        }
        this.pos++;
    }
    if (this.pathElementStart != -1) {
        pushPathElement(createPathElement());
    } 
    return new PathPattern(pathPattern, this.parser, this.headPE);
}

LiteralPathElement
extends PathElement

org.springframework.web.util.pattern.LiteralPathElement

@Override public char[] getChars()

{
    return this.text;
}
org.springframework.web.util.pattern.LiteralPathElement

@Override public int getNormalizedLength()

{
    return this.len;
}
org.springframework.web.util.pattern.LiteralPathElement

@Override public boolean matches(int pathIndex, MatchingContext matchingContext)

{
    if (pathIndex >= matchingContext.pathLength) {
        return false;
    } 
    Element element = matchingContext.pathElements.get(pathIndex);
    if (!(element instanceof PathContainer.PathSegment)) {
        return false;
    } 
    String value = ((PathSegment)element).valueToMatch();
    if (value.length() != this.len) {
        return false;
    } 
    char[] data = ((PathContainer.PathSegment)element).valueToMatchAsChars();
    if (this.caseSensitive) {
        for (int i = 0; i < this.len; i++) {
            if (data[i] != this.text[i]) {
                return false;
            } 
        }
    } else {
        for (int i = 0; i < this.len; i++) {
            if (Character.toLowerCase(data[i]) != this.text[i]) {
                return false;
            } 
        }
    }
    pathIndex++;
    if (isNoMorePattern()) {
        if (matchingContext.determineRemainingPath) {
            matchingContext.remainingPathIndex = pathIndex;
            return true;
        } else {
            if (pathIndex == matchingContext.pathLength) {
                return true;
            } else {
                return (matchingContext.isMatchOptionalTrailingSeparator() && (pathIndex + 1) == matchingContext.pathLength && matchingContext.isSeparator(pathIndex));
            }
        }
    } else {
        return (this.next != null && this.next.matches(pathIndex, matchingContext));
    }
}
org.springframework.web.util.pattern.LiteralPathElement

@Override public String toString()

{
    return "Literal(" + String.valueOf(this.text) + ")";
}

PathElement

org.springframework.web.util.pattern.PathElement

protected static final int CAPTURE_VARIABLE_WEIGHT

org.springframework.web.util.pattern.PathElement

protected static final MultiValueMap<String, String> NO_PARAMETERS

org.springframework.web.util.pattern.PathElement

protected static final int WILDCARD_WEIGHT

org.springframework.web.util.pattern.PathElement

public int getCaptureCount()

{
    return 0;
}
org.springframework.web.util.pattern.PathElement

public abstract char[] getChars()

org.springframework.web.util.pattern.PathElement

public abstract int getNormalizedLength()

org.springframework.web.util.pattern.PathElement

public int getScore()

{
    return 0;
}
org.springframework.web.util.pattern.PathElement

public int getWildcardCount()

{
    return 0;
}
org.springframework.web.util.pattern.PathElement

protected final boolean isNoMorePattern()

{
    return this.next == null;
}
org.springframework.web.util.pattern.PathElement

public abstract boolean matches(int candidatePos, MatchingContext matchingContext)

org.springframework.web.util.pattern.PathElement

@Nullable protected PathElement next

org.springframework.web.util.pattern.PathElement

protected final int pos

org.springframework.web.util.pattern.PathElement

@Nullable protected PathElement prev

org.springframework.web.util.pattern.PathElement

protected final char separator


PathPattern
implements Comparable<PathPattern>

PathMatchInfo

org.springframework.web.util.pattern.PathPattern.PathMatchInfo

public Map<String, MultiValueMap<String, String>> getMatrixVariables()

{
    return this.matrixVariables;
}
org.springframework.web.util.pattern.PathPattern.PathMatchInfo

public Map<String, String> getUriVariables()

{
    return this.uriVariables;
}
org.springframework.web.util.pattern.PathPattern.PathMatchInfo

@Override public String toString()

{
    return "PathMatchInfo[uriVariables=" + this.uriVariables + ", " + "matrixVariables=" + this.matrixVariables + "]";
}
PathRemainingMatchInfo

org.springframework.web.util.pattern.PathPattern.PathRemainingMatchInfo

public Map<String, MultiValueMap<String, String>> getMatrixVariables()

{
    return this.pathMatchInfo.getMatrixVariables();
}
org.springframework.web.util.pattern.PathPattern.PathRemainingMatchInfo

public PathContainer getPathRemaining()

{
    return this.pathRemaining;
}
org.springframework.web.util.pattern.PathPattern.PathRemainingMatchInfo

public Map<String, String> getUriVariables()

{
    return this.pathMatchInfo.getUriVariables();
}
org.springframework.web.util.pattern.PathPattern

public static final Comparator<PathPattern> SPECIFICITY_COMPARATOR

org.springframework.web.util.pattern.PathPattern

public PathPattern combine(PathPattern pattern2string)

{
    if (!StringUtils.hasLength(this.patternString)) {
        if (!StringUtils.hasLength(pattern2string.patternString)) {
            return this.parser.parse("");
        } else {
            return pattern2string;
        }
    } else if (!StringUtils.hasLength(pattern2string.patternString)) {
        return this;
    } 
    if (!this.patternString.equals(pattern2string.patternString) && this.capturedVariableCount == 0 && matches(PathContainer.parsePath(pattern2string.patternString))) {
        return pattern2string;
    } 
    if (this.endsWithSeparatorWildcard) {
        return this.parser.parse(concat(this.patternString.substring(0, this.patternString.length() - 2), pattern2string.patternString));
    } 
    int starDotPos1 = this.patternString.indexOf("*.");
    if (this.capturedVariableCount != 0 || starDotPos1 == -1 || getSeparator() == '.') {
        return this.parser.parse(concat(this.patternString, pattern2string.patternString));
    } 
    String firstExtension = this.patternString.substring(starDotPos1 + 1);
    String p2string = pattern2string.patternString;
    int dotPos2 = p2string.indexOf('.');
    String file2 = (dotPos2 == -1 ? p2string : p2string.substring(0, dotPos2));
    String secondExtension = (dotPos2 == -1 ? "" : p2string.substring(dotPos2));
    boolean firstExtensionWild = (firstExtension.equals(".*") || firstExtension.equals(""));
    boolean secondExtensionWild = (secondExtension.equals(".*") || secondExtension.equals(""));
    if (!firstExtensionWild && !secondExtensionWild) {
        throw new IllegalArgumentException("Cannot combine patterns: " + this.patternString + " and " + pattern2string);
    } 
    return this.parser.parse(file2 + (firstExtensionWild ? secondExtension : firstExtension));
}
org.springframework.web.util.pattern.PathPattern

@Override public boolean equals(@Nullable Object other)

{
    if (!(other instanceof PathPattern)) {
        return false;
    } 
    PathPattern otherPattern = (PathPattern)other;
    return (this.patternString.equals(otherPattern.getPatternString()) && getSeparator() == otherPattern.getSeparator() && this.caseSensitive == otherPattern.caseSensitive);
}
org.springframework.web.util.pattern.PathPattern

public PathContainer extractPathWithinPattern(PathContainer path)

{
    List<Element> pathElements = path.elements();
    int pathElementsCount = pathElements.size();
    int startIndex = 0;
    PathElement elem = this.head;
    while (elem != null) {
        if (elem.getWildcardCount() != 0 || elem.getCaptureCount() != 0) {
            break;
        } 
        elem = elem.next;
        startIndex++;
    }
    if (elem == null) {
        return PathContainer.parsePath("");
    } 
    while (startIndex < pathElementsCount && (pathElements.get(startIndex) instanceof Separator)) {
        startIndex++;
    }
    int endIndex = pathElements.size();
    while (endIndex > 0 && (pathElements.get(endIndex - 1) instanceof Separator)) {
        endIndex--;
    }
    boolean multipleAdjacentSeparators = false;
    for (int i = startIndex; i < (endIndex - 1); i++) {
        if ((pathElements.get(i) instanceof Separator) && (pathElements.get(i + 1) instanceof Separator)) {
            multipleAdjacentSeparators = true;
            break;
        } 
    }
    PathContainer resultPath = null;
    if (multipleAdjacentSeparators) {
        StringBuilder buf = new StringBuilder();
        int i = startIndex;
        while (i < endIndex) {
            Element e = pathElements.get(i++);
            buf.append(e.value());
            if (e instanceof Separator) {
                while (i < endIndex && (pathElements.get(i) instanceof Separator)) {
                    i++;
                }
            } 
        }
        resultPath = PathContainer.parsePath(buf.toString(), this.pathOptions);
    } else if (startIndex >= endIndex) {
        resultPath = PathContainer.parsePath("");
    } else {
        resultPath = path.subPath(startIndex, endIndex);
    }
    return resultPath;
}
org.springframework.web.util.pattern.PathPattern

public String getPatternString()

{
    return this.patternString;
}
org.springframework.web.util.pattern.PathPattern

public boolean hasPatternSyntax()

{
    return (this.score > 0 || this.patternString.indexOf('?') != -1);
}
org.springframework.web.util.pattern.PathPattern

@Override public int hashCode()

{
    return (this.patternString.hashCode() + getSeparator()) * 17 + (this.caseSensitive ? 1 : 0);
}
org.springframework.web.util.pattern.PathPattern

@Nullable public PathMatchInfo matchAndExtract(PathContainer pathContainer)

{
    if (this.head == null) {
        return (hasLength(pathContainer) && !(this.matchOptionalTrailingSeparator && pathContainerIsJustSeparator(pathContainer)) ? null : PathMatchInfo.EMPTY);
    } else if (!hasLength(pathContainer)) {
        if (this.head instanceof WildcardTheRestPathElement || this.head instanceof CaptureTheRestPathElement) {
            pathContainer = EMPTY_PATH;
        } else {
            return null;
        }
    } 
    MatchingContext matchingContext = new MatchingContext(pathContainer, true);
    return this.head.matches(0, matchingContext) ? matchingContext.getPathMatchResult() : null;
}
org.springframework.web.util.pattern.PathPattern

@Nullable public PathRemainingMatchInfo matchStartOfPath(PathContainer pathContainer)

{
    if (this.head == null) {
        return new PathRemainingMatchInfo(pathContainer);
    } else if (!hasLength(pathContainer)) {
        return null;
    } 
    MatchingContext matchingContext = new MatchingContext(pathContainer, true);
    matchingContext.setMatchAllowExtraPath();
    boolean matches = this.head.matches(0, matchingContext);
    if (!matches) {
        return null;
    } else {
        PathRemainingMatchInfo info;
        if (matchingContext.remainingPathIndex == pathContainer.elements().size()) {
            info = new PathRemainingMatchInfo(EMPTY_PATH, matchingContext.getPathMatchResult());
        } else {
            info = new PathRemainingMatchInfo(pathContainer.subPath(matchingContext.remainingPathIndex), matchingContext.getPathMatchResult());
        }
        return info;
    }
}
org.springframework.web.util.pattern.PathPattern

public boolean matches(PathContainer pathContainer)

{
    if (this.head == null) {
        return !hasLength(pathContainer) || (this.matchOptionalTrailingSeparator && pathContainerIsJustSeparator(pathContainer));
    } else if (!hasLength(pathContainer)) {
        if (this.head instanceof WildcardTheRestPathElement || this.head instanceof CaptureTheRestPathElement) {
            pathContainer = EMPTY_PATH;
        } else {
            return false;
        }
    } 
    MatchingContext matchingContext = new MatchingContext(pathContainer, false);
    return this.head.matches(0, matchingContext);
}
org.springframework.web.util.pattern.PathPattern

@Override public String toString()

{
    return this.patternString;
}

PathPatternParser

org.springframework.web.util.pattern.PathPatternParser

public PathContainer.Options getPathOptions()

{
    return this.pathOptions;
}
org.springframework.web.util.pattern.PathPatternParser

public boolean isCaseSensitive()

{
    return this.caseSensitive;
}
org.springframework.web.util.pattern.PathPatternParser

public boolean isMatchOptionalTrailingSeparator()

{
    return this.matchOptionalTrailingSeparator;
}
org.springframework.web.util.pattern.PathPatternParser

public PathPattern parse(String pathPattern)

{
    return new InternalPathPatternParser(this).parse(pathPattern);
}
org.springframework.web.util.pattern.PathPatternParser

public void setCaseSensitive(boolean caseSensitive)

{
    this.caseSensitive = caseSensitive;
}
org.springframework.web.util.pattern.PathPatternParser

public void setMatchOptionalTrailingSeparator(boolean matchOptionalTrailingSeparator)

{
    this.matchOptionalTrailingSeparator = matchOptionalTrailingSeparator;
}
org.springframework.web.util.pattern.PathPatternParser

public void setPathOptions(PathContainer.Options pathOptions)

{
    this.pathOptions = pathOptions;
}

PathPatternRouteMatcher
implements RouteMatcher

org.springframework.web.util.pattern.PathPatternRouteMatcher

public PathPatternRouteMatcher PathPatternRouteMatcher()

{
    this.parser = new PathPatternParser();
    this.parser.setPathOptions(PathContainer.Options.MESSAGE_ROUTE);
    this.parser.setMatchOptionalTrailingSeparator(false);
}
org.springframework.web.util.pattern.PathPatternRouteMatcher

public PathPatternRouteMatcher PathPatternRouteMatcher(PathPatternParser parser)

{
    Assert.notNull(parser, "PathPatternParser must not be null");
    this.parser = parser;
}
org.springframework.web.util.pattern.PathPatternRouteMatcher

@Override public String combine(String pattern1, String pattern2)

{
    return getPathPattern(pattern1).combine(getPathPattern(pattern2)).getPatternString();
}
org.springframework.web.util.pattern.PathPatternRouteMatcher

@Override public Comparator<String> getPatternComparator(Route route)

{
    return Comparator.comparing(this::getPathPattern);
}
org.springframework.web.util.pattern.PathPatternRouteMatcher

@Override public boolean isPattern(String route)

{
    return getPathPattern(route).hasPatternSyntax();
}
org.springframework.web.util.pattern.PathPatternRouteMatcher

@Override public boolean match(String pattern, Route route)

{
    return getPathPattern(pattern).matches(getPathContainer(route));
}
org.springframework.web.util.pattern.PathPatternRouteMatcher

@Override @Nullable public Map<String, String> matchAndExtract(String pattern, Route route)

{
    PathPattern.PathMatchInfo info = getPathPattern(pattern).matchAndExtract(getPathContainer(route));
    return info != null ? info.getUriVariables() : null;
}
org.springframework.web.util.pattern.PathPatternRouteMatcher

@Override public Route parseRoute(String routeValue)

{
    return new PathContainerRoute(PathContainer.parsePath(routeValue, this.parser.getPathOptions()));
}

PatternParseException
extends IllegalArgumentException

PatternMessage

enum values
  • MISSING_CLOSE_CAPTURE
  • MISSING_OPEN_CAPTURE
  • ILLEGAL_NESTED_CAPTURE
  • CANNOT_HAVE_ADJACENT_CAPTURES
  • ILLEGAL_CHARACTER_AT_START_OF_CAPTURE_DESCRIPTOR
  • ILLEGAL_CHARACTER_IN_CAPTURE_DESCRIPTOR
  • NO_MORE_DATA_EXPECTED_AFTER_CAPTURE_THE_REST
  • BADLY_FORMED_CAPTURE_THE_REST
  • MISSING_REGEX_CONSTRAINT
  • ILLEGAL_DOUBLE_CAPTURE
  • REGEX_PATTERN_SYNTAX_EXCEPTION
  • CAPTURE_ALL_IS_STANDALONE_CONSTRUCT
org.springframework.web.util.pattern.PatternParseException

public String formatMessage(Object... inserts)

{
    return MessageFormat.format(this.message, inserts);
}
org.springframework.web.util.pattern.PatternParseException

public Object[] getInserts()

{
    return this.inserts;
}
org.springframework.web.util.pattern.PatternParseException

@Override public String getMessage()

{
    return this.messageType.formatMessage(this.inserts);
}
org.springframework.web.util.pattern.PatternParseException

public PatternMessage getMessageType()

{
    return this.messageType;
}
org.springframework.web.util.pattern.PatternParseException

public int getPosition()

{
    return this.position;
}
org.springframework.web.util.pattern.PatternParseException

public String toDetailedString()

{
    StringBuilder buf = new StringBuilder();
    buf.append(this.pattern).append('\n');
    for (int i = 0; i < this.position; i++) {
        buf.append(' ');
    }
    buf.append("^\n");
    buf.append(getMessage());
    return buf.toString();
}

RegexPathElement
extends PathElement

org.springframework.web.util.pattern.RegexPathElement

public Pattern buildPattern(char[] regex, char[] completePattern)

{
    StringBuilder patternBuilder = new StringBuilder();
    String text = new String(regex);
    Matcher matcher = GLOB_PATTERN.matcher(text);
    int end = 0;
    while (matcher.find()) {
        patternBuilder.append(quote(text, end, matcher.start()));
        String match = matcher.group();
        if ("?".equals(match)) {
            patternBuilder.append('.');
        } else if ("*".equals(match)) {
            patternBuilder.append(".*");
            int pos = matcher.start();
            if (pos < 1 || text.charAt(pos - 1) != '.') {
                this.wildcardCount++;
            } 
        } else if (match.startsWith("{") && match.endsWith("}")) {
            int colonIdx = match.indexOf(':');
            if (colonIdx == -1) {
                patternBuilder.append(DEFAULT_VARIABLE_PATTERN);
                String variableName = matcher.group(1);
                if (this.variableNames.contains(variableName)) {
                    throw new PatternParseException(this.pos, completePattern, PatternParseException.PatternMessage.ILLEGAL_DOUBLE_CAPTURE, variableName);
                } 
                this.variableNames.add(variableName);
            } else {
                String variablePattern = match.substring(colonIdx + 1, match.length() - 1);
                patternBuilder.append('(');
                patternBuilder.append(variablePattern);
                patternBuilder.append(')');
                String variableName = match.substring(1, colonIdx);
                if (this.variableNames.contains(variableName)) {
                    throw new PatternParseException(this.pos, completePattern, PatternParseException.PatternMessage.ILLEGAL_DOUBLE_CAPTURE, variableName);
                } 
                this.variableNames.add(variableName);
            }
        } 
        end = matcher.end();
    }
    patternBuilder.append(quote(text, end, text.length()));
    if (this.caseSensitive) {
        return Pattern.compile(patternBuilder.toString());
    } else {
        return Pattern.compile(patternBuilder.toString(), Pattern.CASE_INSENSITIVE);
    }
}
org.springframework.web.util.pattern.RegexPathElement

@Override public int getCaptureCount()

{
    return this.variableNames.size();
}
org.springframework.web.util.pattern.RegexPathElement

@Override public char[] getChars()

{
    return this.regex;
}
org.springframework.web.util.pattern.RegexPathElement

@Override public int getNormalizedLength()

{
    int varsLength = 0;
    for (String variableName: this.variableNames) {
        varsLength += variableName.length();
    }
    return (this.regex.length - varsLength - this.variableNames.size());
}
org.springframework.web.util.pattern.RegexPathElement

@Override public int getScore()

{
    return (getCaptureCount() * CAPTURE_VARIABLE_WEIGHT + getWildcardCount() * WILDCARD_WEIGHT);
}
org.springframework.web.util.pattern.RegexPathElement

public List<String> getVariableNames()

{
    return this.variableNames;
}
org.springframework.web.util.pattern.RegexPathElement

@Override public int getWildcardCount()

{
    return this.wildcardCount;
}
org.springframework.web.util.pattern.RegexPathElement

@Override public boolean matches(int pathIndex, MatchingContext matchingContext)

{
    String textToMatch = matchingContext.pathElementValue(pathIndex);
    Matcher matcher = this.pattern.matcher(textToMatch);
    boolean matches = matcher.matches();
    if (matches) {
        if (isNoMorePattern()) {
            if (matchingContext.determineRemainingPath && (this.variableNames.isEmpty() ? true : textToMatch.length() > 0)) {
                matchingContext.remainingPathIndex = pathIndex + 1;
                matches = true;
            } else {
                matches = (pathIndex + 1) >= matchingContext.pathLength && (this.variableNames.isEmpty() || textToMatch.length() > 0);
                if (!matches && matchingContext.isMatchOptionalTrailingSeparator()) {
                    matches = (this.variableNames.isEmpty() || textToMatch.length() > 0) && (pathIndex + 2) >= matchingContext.pathLength && matchingContext.isSeparator(pathIndex + 1);
                } 
            }
        } else {
            matches = (this.next != null && this.next.matches(pathIndex + 1, matchingContext));
        }
    } 
    if (matches && matchingContext.extractingVariables) {
        if (this.variableNames.size() != matcher.groupCount()) {
            throw new IllegalArgumentException("The number of capturing groups in the pattern segment " + this.pattern + " does not match the number of URI template variables it defines, " + "which can occur if capturing groups are used in a URI template regex. " + "Use non-capturing groups instead.");
        } 
        for (int i = 1; i <= matcher.groupCount(); i++) {
            String name = this.variableNames.get(i - 1);
            String value = matcher.group(i);
            matchingContext.set(name, value, (i == this.variableNames.size()) ? ((PathSegment)matchingContext.pathElements.get(pathIndex)).parameters() : NO_PARAMETERS);
        }
    } 
    return matches;
}
org.springframework.web.util.pattern.RegexPathElement

@Override public String toString()

{
    return "Regex(" + String.valueOf(this.regex) + ")";
}

SeparatorPathElement
extends PathElement

org.springframework.web.util.pattern.SeparatorPathElement

@Override public char[] getChars()

{
    return new char[]{this.separator};
}
org.springframework.web.util.pattern.SeparatorPathElement

@Override public int getNormalizedLength()

{
    return 1;
}
org.springframework.web.util.pattern.SeparatorPathElement

@Override public String toString()

{
    return "Separator(" + this.separator + ")";
}

SingleCharWildcardedPathElement
extends PathElement

org.springframework.web.util.pattern.SingleCharWildcardedPathElement

public SingleCharWildcardedPathElement SingleCharWildcardedPathElement(int pos, char[] literalText, int questionMarkCount, boolean caseSensitive, char separator)

{
    super(pos, separator);
    this.len = literalText.length;
    this.questionMarkCount = questionMarkCount;
    this.caseSensitive = caseSensitive;
    if (caseSensitive) {
        this.text = literalText;
    } else {
        this.text = new char[literalText.length];
        for (int i = 0; i < this.len; i++) {
            this.text[i] = Character.toLowerCase(literalText[i]);
        }
    }
}
org.springframework.web.util.pattern.SingleCharWildcardedPathElement

@Override public char[] getChars()

{
    return this.text;
}
org.springframework.web.util.pattern.SingleCharWildcardedPathElement

@Override public int getNormalizedLength()

{
    return this.len;
}
org.springframework.web.util.pattern.SingleCharWildcardedPathElement

@Override public int getWildcardCount()

{
    return this.questionMarkCount;
}
org.springframework.web.util.pattern.SingleCharWildcardedPathElement

@Override public String toString()

{
    return "SingleCharWildcarded(" + String.valueOf(this.text) + ")";
}

SubSequence
implements CharSequence

org.springframework.web.util.pattern.SubSequence

@Override public char charAt(int index)

{
    return this.chars[this.start + index];
}
org.springframework.web.util.pattern.SubSequence

@Override public int length()

{
    return (this.end - this.start);
}
org.springframework.web.util.pattern.SubSequence

@Override public CharSequence subSequence(int start, int end)

{
    return new SubSequence(this.chars, this.start + start, this.start + end);
}
org.springframework.web.util.pattern.SubSequence

@Override public String toString()

{
    return new String(this.chars, this.start, this.end - this.start);
}

WildcardPathElement
extends PathElement

org.springframework.web.util.pattern.WildcardPathElement

public WildcardPathElement WildcardPathElement(int pos, char separator)

{
    super(pos, separator);
}
org.springframework.web.util.pattern.WildcardPathElement

@Override public char[] getChars()

{
    return new char[]{'*'};
}
org.springframework.web.util.pattern.WildcardPathElement

@Override public int getNormalizedLength()

{
    return 1;
}
org.springframework.web.util.pattern.WildcardPathElement

@Override public int getScore()

{
    return WILDCARD_WEIGHT;
}
org.springframework.web.util.pattern.WildcardPathElement

@Override public int getWildcardCount()

{
    return 1;
}
org.springframework.web.util.pattern.WildcardPathElement

@Override public String toString()

{
    return "Wildcard(*)";
}

WildcardTheRestPathElement
extends PathElement

org.springframework.web.util.pattern.WildcardTheRestPathElement

@Override public char[] getChars()

{
    return (this.separator + "**").toCharArray();
}
org.springframework.web.util.pattern.WildcardTheRestPathElement

@Override public int getNormalizedLength()

{
    return 1;
}
org.springframework.web.util.pattern.WildcardTheRestPathElement

@Override public int getWildcardCount()

{
    return 1;
}
org.springframework.web.util.pattern.WildcardTheRestPathElement

@Override public boolean matches(int pathIndex, PathPattern.MatchingContext matchingContext)

{
    if (pathIndex < matchingContext.pathLength && !matchingContext.isSeparator(pathIndex)) {
        return false;
    } 
    if (matchingContext.determineRemainingPath) {
        matchingContext.remainingPathIndex = matchingContext.pathLength;
    } 
    return true;
}
org.springframework.web.util.pattern.WildcardTheRestPathElement

@Override public String toString()

{
    return "WildcardTheRest(" + this.separator + "**)";
}